# -*- coding: utf-8 -*-

 ###############################################
 ##                                             ##
 ##   Submódulo vista                            ##
 ##   @ Módulo productos                         ##
 ##                                              ##
 ##   de la línea Básicos                        ##
 ##   de Críptidos Digitales                     ##
 ##   GPL (c)2008                                ##
  ##                                             ##
    ###############################################



import sys
from decimal import Decimal as dec
from PyQt4 import QtCore, QtGui

from cdWidgets import cdLineEdit, cdNumberEdit

if cdLineEdit.version < 2.2:
    print u"Debe actualizar la versión del módulo cdLineEdit a 2.2 o posterior"
import frame_ui
import administradorProductos_ui as administrador_ui
import capturaProducto_ui as captura_ui
import detallesProducto_ui as detalles_ui
import capturaAcepcion_ui
import aceptionsCapture_ui
# import informacion

import manejador

controller = None




class Forma(QtGui.QFrame):

    def __init__(self, *args, **kwds):

        global controller

        if kwds.has_key('controller'):
            controller = kwds.pop('controller')
            manejador.controller = controller
        else:
            controller = None

        if kwds.has_key('app'):
            self.__app = kwds.pop('app')
        else:
            self.__app = None

        if kwds.has_key('owner'):
            self.__owner = kwds.pop('owner')
        else:
            self.__owner = None

        QtGui.QFrame.__init__(self, *args)

        self.ui = frame_ui.Ui_Form()
        self.ui.setupUi(self)

        self.ui.frame1.close()
        self.ui.frame2.close()
        self.ui.frame3.close()

        ## Rangos de precio activos
        self.__rangosPrecioActivos = manejador.rangosPrecio(activo=True)
        # self.cargaRangosPrecioActivos()

        ## Detalles
        self.detalles = Detalles(self, owner=self)
        self.detalles.hide()
        self.detalles.status = 'normal'

        ## Captura

        self.captura = Captura(self, owner=self)
        self.connect(self.captura, QtCore.SIGNAL('capturaClosed()'), self.capturaClosed)
        self.captura.hide()

        ## Administrador
        self.administrador = Administrador(self, owner=self)

        self.ui.outerSplitter = Splitter(QtCore.Qt.Vertical, self)
        ## InnerSplitter
        self.ui.innerSplitter = Splitter(QtCore.Qt.Horizontal, self.ui.outerSplitter)
        self.ui.innerSplitter.insertWidget(0, self.administrador)
        self.ui.innerSplitter.insertWidget(1, self.detalles)
        self.connect(self.ui.innerSplitter.handle(1), QtCore.SIGNAL("handlePressed"), self.innerHandlePressed)
        self.ui.innerSplitter.setSizes([1, 1])

        ## OuterSplitter
        self.ui.outerSplitter.insertWidget(0, self.ui.innerSplitter)
        self.ui.outerSplitter.insertWidget(1, self.captura)
        self.connect(self.ui.outerSplitter.handle(1), QtCore.SIGNAL('handlePressed'), self.outerHandlePressed)
        self.ui.outerSplitter.setSizes([1, 1])
        self.ui.verticalLayout.addWidget(self.ui.outerSplitter)


        # self.connect(controller.eventRouter, QtCore.SIGNAL('rangosPrecioChangedBroadcast()'), self.rangosPrecioChanged)

        # self.connect(self.parent(), QtCore.SIGNAL('capturaClasificacionObligatoriaChangedBroadcast'), self.capturaClasificacionObligatoriaChangedBroadcast)
        # self.connect(self.parent(), QtCore.SIGNAL('capturaActualPermitidaChangedBroadcast'), self.capturaActualPermitidaChangedBroadcast)
        # self.connect(self.parent(), QtCore.SIGNAL('capturaLineaToggledBroadcast()'), self.capturaLineaToggledBroadcast)
        # self.connect(self.parent(), QtCore.SIGNAL('tipoProductoDefaultChangedBroadcast'), self.tipoProductoDefaultChangedBroadcast)


    # def capturaActualPermitidaChangedBroadcast(self):   # print "productos.igu.Forma.capturaActualPermitidaChangedBroadcast()"
        # self.emit(QtCore.SIGNAL('capturaActualPermitidaChangedBroadcast'))

    # def capturaLineaToggledBroadcast(self):
        # print "productos.igu.Forma.capturaLineaToggledBroadcast()"
        # self.emit(QtCore.SIGNAL('capturaLineaToggledBroadcast()'))

    # def capturaClasificacionObligatoriaChangedBroadcast(self):  # print "productos.igu.Forma.capturaClasificacionObligatoriaChangedBroadcast()"
        # self.emit(QtCore.SIGNAL('capturaClasificacionObligatoriaChangedBroadcast'))


    # def rangosPrecioChanged(self):          # print "productos.igu.Forma.rangosPrecioChanged()"
        # self.cargaRangosPrecioActivos()
        #! Falta actualizar vistas involucradas


    # def cargaRangosPrecioActivos(self):     # print "productos.igu.Forma.cargaRangosPrecioActivos()"
        # rangosPrecio = manejador.dameRangosPrecio()
        # self.__rangosPrecioActivos = []
        # for index, rango in enumerate(rangosPrecio):
            # if 'a' in rango.referencia:
                # self.__rangosPrecioActivos.append(rango)


    def capturaClosed(self):                # print "productos.igu.Forma.capturaClosed()"
        self.setInnerStatus("visible")
        self.administrador.actualizaBotones()

    def innerHandlePressed(self):
        self.toggleDetalles()

    def outerHandlePressed(self):           # print "productos.igu.Forma.outerHandlePressed()"
        if self.ui.outerSplitter.sizes()[0] == 0:
            self.setInnerStatus('visible')
        else:
            self.setInnerStatus('hidden')

    @property
    def owner(self):
        return self.__owner

    @property
    def rangosPrecioActivos(self):
        return self.__rangosPrecioActivos

    def setInnerStatus(self, value):        # print "productos.igu.Forma.setInnerStatus(%s)" % value
        if value == 'visible':
            self.administrador.show()
            if self.detalles.status == 'hidden':
                self.detalles.show()
                self.detalles.status = "normal"

        elif value == 'hidden':
            self.administrador.hide()
            if self.detalles.isVisible():
                self.detalles.status = "hidden"
                self.detalles.hide()

        elif value == 'disabled':
            print 'disables'

    # def tipoProductoDefaultChangedBroadcast(self):
        # self.emit(QtCore.SIGNAL('tipoProductoDefaultChangedBroadcast'))

    def toggleDetalles(self, *args):        # print "pedidos.igu.Forma.toggleDetalles()"
        if self.detalles.isVisible():
            self.detalles.hide()
        else:
            self.detalles.show()
            if self.administrador.ui.tablaConsulta.currentRow() != -1:
                id = self.administrador.ui.tablaConsulta.item(self.administrador.ui.tablaConsulta.currentRow(), 0).data(1000).toInt()[0]
                #~ data = manejador.dameUno(id=id)
                self.detalles.mostrar(id)




class Administrador(QtGui.QFrame):

    def __init__(self, *args, **kwds):
        # self.contenedor = args[0]

        if kwds.has_key('owner'):
            self.__owner = kwds.pop('owner')
        else:
            self.__owner = None

        QtGui.QFrame.__init__(self, *args)

        self.ui = administrador_ui.Ui_Form()
        self.ui.setupUi(self)

        ## FILTROS
        self.ui.cbProveedor.setStyleSheet("background-color:#F8F8F8;")

        self.ui.frClasificacion.hide()
        # self.ui.cbClasificacion.setStyleSheet("background-color:#F8F8F8")

        self.ui.cbTipo.setStyleSheet("background-color:#F8F8F8;")

        self.connect(self.ui.cbProveedor, QtCore.SIGNAL("currentIndexChanged(int)"), self.currentProveedorChanged)
        self.connect(self.ui.cbClasificacion, QtCore.SIGNAL('currentIndexChanged(int)'), self.currentClasificacionChanged)
        self.connect(self.ui.cbTipo, QtCore.SIGNAL("currentIndexChanged(int)"), self.currentTipoChanged)

        ## TABLA DE CONSULTA
        self.ui.tablaConsulta.setShowGrid(True)
        self.ui.tablaConsulta.setSelectionMode(QtGui.QAbstractItemView.SingleSelection)
        self.ui.tablaConsulta.setSelectionBehavior(QtGui.QAbstractItemView.SelectRows)
        self.ui.tablaConsulta.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
        labels = [u"Código", u"Nombre", u"Línea", u"Clasificación", u"Costo", u"Descuento", u"Precio", u"Existencia"]
        self.ui.tablaConsulta.setColumnCount(len(labels))
        self.ui.tablaConsulta.setHorizontalHeaderLabels(labels)
        # self.ui.tablaConsulta.horizontalHeader().setStretchLastSection(False)

        self.connect(self.ui.tablaConsulta, QtCore.SIGNAL("itemDoubleClicked(QTableWidgetItem *)"), self.owner.toggleDetalles)
        self.connect(self.ui.tablaConsulta, QtCore.SIGNAL("itemSelectionChanged()"), self.selectionChanged)
        self.connect(self.ui.tablaConsulta, QtCore.SIGNAL("resized(QEvent)"), self.resizedTablaConsulta)
        self.connect(self.ui.tablaConsulta, QtCore.SIGNAL("customContextMenuRequested(QPoint)"), self.mostrarMenuConsulta)

        ## Agregar
        icon = QtGui.QIcon()
        icon.addPixmap(QtGui.QPixmap("imagenes/Plus.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
        self.aAgregar = QtGui.QAction(icon, u"Agregar", self)
        self.aAgregar.setCheckable(True)
        self.aAgregar.setIconText(u"&Agregar")
        self.connect(self.aAgregar, QtCore.SIGNAL("triggered()"), self.agrega)

        self.ui.toAgregar.setDefaultAction(self.aAgregar)
        self.ui.toAgregar.setIconSize(QtCore.QSize(44, 40))
        self.ui.toAgregar.setToolButtonStyle(QtCore.Qt.ToolButtonTextUnderIcon)

        ## Modificar
        icon = QtGui.QIcon()
        icon.addPixmap(QtGui.QPixmap("imagenes/Redo.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
        self.aModificar = QtGui.QAction(icon, u"Modificar", self)
        self.aModificar.setCheckable(True)
        self.aModificar.setIconText(u"&Modificar")
        self.connect(self.aModificar, QtCore.SIGNAL("triggered()"), self.modifica)

        self.ui.toModificar.setDefaultAction(self.aModificar)
        self.ui.toModificar.setIconSize(QtCore.QSize(44, 40))
        self.ui.toModificar.setToolButtonStyle(QtCore.Qt.ToolButtonTextUnderIcon)

        ## Eliminar
        icon = QtGui.QIcon()
        icon.addPixmap(QtGui.QPixmap("imagenes/Minus.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
        self.aEliminar = QtGui.QAction(icon, u"Eliminar", self)
        self.aEliminar.setCheckable(True)
        self.aEliminar.setIconText(u"&Eliminar")
        self.connect(self.aEliminar, QtCore.SIGNAL("triggered()"), self.elimina)

        self.ui.toEliminar.setDefaultAction(self.aEliminar)
        self.ui.toEliminar.setIconSize(QtCore.QSize(44, 40))
        self.ui.toEliminar.setToolButtonStyle(QtCore.Qt.ToolButtonTextUnderIcon)

        ## Imprimir
        icon = QtGui.QIcon()
        icon.addPixmap(QtGui.QPixmap("imagenes/Print.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
        self.aImprimir = QtGui.QAction(icon, u"Imprimir", self)
        self.aImprimir.setIconText(u"&Imprimir")
        self.connect(self.aImprimir, QtCore.SIGNAL("triggered()"), self.imprime)

        self.ui.toImprimir.setDefaultAction(self.aImprimir)
        self.ui.toImprimir.setIconSize(QtCore.QSize(44, 40))
        self.ui.toImprimir.setToolButtonStyle(QtCore.Qt.ToolButtonTextUnderIcon)

        self.menuTablaConsulta = QtGui.QMenu(self)
        self.menuTablaConsulta.addAction(self.aAgregar)
        self.menuTablaConsulta.addAction(self.aModificar)
        self.menuTablaConsulta.addAction(self.aEliminar)

        self.connect(controller.eventRouter, QtCore.SIGNAL('clasificacionesChangedBroadcast()'), self.cargaClasificaciones)

        self.connect(controller.eventRouter, QtCore.SIGNAL('lineasChangedBroadcast()'), self.cargaLineas)

        self.connect(controller.eventRouter, QtCore.SIGNAL('productosChangedBroadcast()'), self.actualizaConsulta)

        # self.connect(controller.eventRouter, QtCore.SIGNAL('addProduct(bool)'), self.agrega)

        self.impresor = QtGui.QPrinter()

        self.cargaProveedores()
        self.cargaClasificaciones()
        self.cargaTipos()

        self.actualizaConsulta()

        self.ui.tablaConsulta.sortItems(0, QtCore.Qt.AscendingOrder)


    def actualizaBotones(self):
        if not self.owner.captura.isVisible():
            self.aAgregar.setChecked(False)
            self.aModificar.setChecked(False)
        self.aEliminar.setChecked(False)

        mensajesFiltros = u""
        mensajesAgregar = u""
        mensajesModificar = u""
        mensajesEliminar = u""
        mensajesImprimir = u""

        if manejador.totalDeProveedores() == 0:
            self.ui.frProveedor.setEnabled(False)
            self.ui.cbProveedor.setToolTip(u"No hay proveedores registrados")
        else:
            self.ui.frProveedor.setEnabled(True)
            self.ui.cbProveedor.setToolTip(u"")

        if manejador.totalDeProductos() == 0:
            mensajesFiltros += u"No hay productos registrados\n"
            mensajesModificar += u"No hay Productos registrados\n"
            mensajesEliminar += u"No hay productos registrados\n"

        if self.ui.tablaConsulta.rowCount() == 0:
            mensajesModificar += u"No hay productos desplegados\n"
            mensajesEliminar += u"No hay Productos desplegados\n"
            mensajesImprimir += u"No hay productos desplegados\n"
        else:
            if self.ui.tablaConsulta.currentRow() == -1:
                mensajesModificar += u"Selecciona el Producto que quieres modificar\n"
                mensajesEliminar += u"Selecciona el Producto que quieres eliminar\n"

        if mensajesFiltros:
            self.ui.frFiltros.setEnabled(False)
            self.ui.frFiltros.setToolTip(mensajesFiltros.rstrip("\n"))
        else:
            self.ui.frFiltros.setEnabled(True)
            self.ui.frFiltros.setToolTip(u"")

        if mensajesAgregar:
            self.aAgregar.setEnabled(False)
            self.aAgregar.setToolTip(mensajesAgregar.rstrip("\n"))
        else:
            self.aAgregar.setEnabled(True)
            self.aAgregar.setToolTip(u"Presiona para registrar un Producto nuevo")

        if mensajesModificar:
            self.aModificar.setEnabled(False)
            self.aModificar.setToolTip(mensajesModificar.rstrip("\n"))
        else:
            self.aModificar.setEnabled(True)
            self.aModificar.setToolTip(u"Presiona para modificar los datos del Producto seleccionado")

        if mensajesEliminar:
            self.aEliminar.setEnabled(False)
            self.aEliminar.setToolTip(mensajesEliminar.rstrip("\n"))
        else:
            self.aEliminar.setEnabled(True)
            self.aEliminar.setToolTip(u"Presiona para eliminar el producto seleccionado")

        if mensajesImprimir:
            self.aImprimir.setEnabled(False)
            self.aImprimir.setToolTip(mensajesImprimir.rstrip("\n"))
        else:
            self.aImprimir.setEnabled(True)
            self.aImprimir.setToolTip(u"Presiona para Imprimir los productos mostrados")



    def actualizaConsulta(self):
        m = "productos.igu.Administrador.actualizaConsulta()"

        filtros = {}
        if self.ui.cbProveedor.currentIndex() > 0:
            filtros['rol_id'] = self.ui.cbProveedor.itemData(self.ui.cbProveedor.currentIndex()).toInt()[0]
        else:
            filtros['rol_id'] = controller.app.holder.id

        if self.ui.cbClasificacion.currentIndex() > 0:
            filtros['clasificacion_id'] = self.ui.cbClasificacion.itemData(self.ui.cbClasificacion.currentIndex())

        if self.ui.cbTipo.currentIndex() > 0:
            filtros['tipo_id'] = self.ui.cbTipo.itemData(self.ui.cbTipo.currentIndex())

        old = self.currentId()

        registros = manejador.dameAcepciones(**filtros)

        self.ui.tablaConsulta.setRowCount(0)
        # self.ui.tablaConsulta.setRowCount(len(registros))

        self.ui.tablaConsulta.setSortingEnabled(False)

        for row, acepcion in enumerate(registros):
            try:
                self.ui.tablaConsulta.insertRow(row)

                col = 0
                item = QtGui.QTableWidgetItem(acepcion.codigo)
                item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
                item.setData(1000, QtCore.QVariant(acepcion.id))
                self.ui.tablaConsulta.setItem(row, 0, item)

                col = 1
                item = QtGui.QTableWidgetItem(acepcion.nombre)
                item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
                self.ui.tablaConsulta.setItem(row, 1, item)

                col = 2
                if acepcion.producto.lineas:
                    item = QtGui.QTableWidgetItem(acepcion.producto.lineas[0].nombre)
                    item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
                    self.ui.tablaConsulta.setItem(row, 2, item)

                col = 3
                if acepcion.producto.clasificacion:
                    item = QtGui.QTableWidgetItem(acepcion.producto.clasificacion.nombre)
                    item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
                    self.ui.tablaConsulta.setItem(row, 3, item)

                col = 4
                ## COSTO
                if acepcion.costo:
                    item = QtGui.QTableWidgetItem("%8.4f" % acepcion.costo)
                else:
                    item = QtGui.QTableWidgetItem("")
                item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
                item.setTextAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignVCenter)
                self.ui.tablaConsulta.setItem(row, 4, item)

                col = 5
                ## Descuento
                if acepcion.rol_id == controller.app.holder.id:
                    if acepcion.descuentoindividual:
                        item = QtGui.QTableWidgetItem("%8.2f" % acepcion.descuentoindividual)
                    else:
                        item = QtGui.QTableWidgetItem("0")
                else:
                    if acepcion.descuentogeneral:
                        item = QtGui.QTableWidgetItem("%8.2f" % acepcion.descuentogeneral)
                    else:
                        item = QtGui.QTableWidgetItem("0")
                item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
                item.setTextAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignVCenter)
                self.ui.tablaConsulta.setItem(row, 5, item)

                col = 6
                ## PRECIOS
                precios = ""
                for index, rango in enumerate(self.owner.rangosPrecioActivos):
                    atributoCero = [x for x in acepcion.producto.atributos if x.atributo_id==rango.id]
                    if atributoCero:
                        atributo = atributoCero[0]
                        precios += "%8.4f, " % float(atributo.valor)
                if precios:
                    item = QtGui.QTableWidgetItem(precios.rstrip(', '))
                else:
                    item = QtGui.QTableWidgetItem("0.0000")
                item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
                item.setTextAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignVCenter)
                self.ui.tablaConsulta.setItem(row, 6, item)

                col = 7
                item = QtGui.QTableWidgetItem("%8.f" % acepcion.producto.actual)
                item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
                item.setTextAlignment(QtCore.Qt.AlignHCenter|QtCore.Qt.AlignVCenter)
                self.ui.tablaConsulta.setItem(row, 7, item)

            except:
                print
                print "ERROR @ productos.igu.Administrador.actualizaConsulta()"
                print sys.exc_info()
                print col
                print acepcion.producto
                print acepcion

        self.ui.tablaConsulta.setSortingEnabled(True)

        self.setCurrentId(old)

        self.actualizaBotones()


    def agrega(self, secondary=False):
        m = "productos.igu.Administrador.agrega()"

        self.owner.captura.agrega()


    def cargaClasificaciones(self):
        clasificaciones = manejador.clasificaciones()

        old = self.ui.cbClasificacion.currentText()
        self.ui.cbClasificacion.clear()
        self.ui.cbClasificacion.addItem("")
        for clasificacion in clasificaciones:
            self.ui.cbClasificacion.addItem(clasificacion.nombre, QtCore.QVariant(clasificacion.id))

        if old > 0:
            self.ui.cbClasificacion.setCurrentIndex(self.ui.cbClasificacion.findText(old))
        else:
            self.ui.cbClasificacion.setCurrentIndex(0)


    def cargaLineas(self):
        lineas = manejador.lineas()

        old = self.ui.cbLinea.currentText()
        self.ui.cbLinea.clear()
        self.ui.cbLinea.addItem("")
        for linea in lineas:
            self.ui.cbLinea.addItem(linea.nombre, QtCore.QVariant(linea.id))

        if old > 0:
            self.ui.cbLinea.setCurrentIndex(self.ui.cbLinea.findText(old))
        else:
            self.ui.cbLinea.setCurrentIndex(0)

        self.actualizaConsulta()


    def cargaProveedores(self):
        proveedores = manejador.proveedores()
        self.ui.cbProveedor.clear()
        self.ui.cbProveedor.addItem("Local", QtCore.QVariant(controller.app.holder.id))
        for proveedor in proveedores:
            self.ui.cbProveedor.addItem("%s %s" % (proveedor.entidad.nombre, proveedor.entidad.nombre2), QtCore.QVariant(proveedor.id))


    def cargaTipos(self):
        tipos = manejador.tipos()
        self.ui.cbTipo.clear()
        for tipo in tipos:
            self.ui.cbTipo.addItem(tipo.nombre, QtCore.QVariant(tipo.id))


    def currentId(self):
        if self.ui.tablaConsulta.currentRow() != -1:
            id = self.ui.tablaConsulta.item(self.ui.tablaConsulta.currentRow(), 0).data(1000).toInt()[0]
        else:
            id = None
        return id


    def currentClasificacionChanged(self, index):
        self.actualizaConsulta()


    def currentProveedorChanged(self, index): # print "productos.igu.Administrador.currentProveedorChanged()"
        self.actualizaConsulta()


    def currentTipoChanged(self, index):
        self.actualizaConsulta()


    def elimina(self):
        if self.ui.tablaConsulta.currentRow() < 0:
            result = QtGui.QMessageBox.information(self, u"Empresa Básica - Eliminar producto", u"Selecciona el PRODUCTO que quieres eliminar", QtGui.QMessageBox.Ok, QtGui.QMessageBox.Ok)
        else:
            id = self.ui.tablaConsulta.item(self.ui.tablaConsulta.currentRow(), 0).data(1000).toInt()[0]
            acepcion = manejador.acepcionI(id=id)

            result = QtGui.QMessageBox.warning(self, u"Empresa Básica - Eliminar producto", u"¿Realmente quieres eliminar el Producto\n\n%s?" % acepcion.nombre, QtGui.QMessageBox.Yes | QtGui.QMessageBox.No, QtGui.QMessageBox.No)

            if result == QtGui.QMessageBox.Yes:
                manejador.elimina(id=id)
                controller.eventRouter.emit(QtCore.SIGNAL("productosChangedBroadcast()"))

    def findData(self, data):
        index = -1
        for row in range(self.ui.tablaConsulta.rowCount()):
            if self.ui.tablaConsulta.item(row, 0).data(1000)==QtCore.QVariant(data):
                index = row
        return index


    def imprime(self):              # print "productos.igu.Administrador.imprime()"
        dialogoImpresora = QtGui.QPrintDialog(self.impresor)

        if dialogoImpresora.exec_() == QtGui.QDialog.Accepted:

            margenHorizontal, margenVertical = [10, 10]
            pageNo = 1

            # result = QtGui.QMessageBox.information(self, u"Empresa Básica - Impresión de pedido", u"Imprimiendo ...", QtGui.QMessageBox.Ok, QtGui.QMessageBox.Ok)

            painter = QtGui.QPainter(self.impresor)

            font1 = QtGui.QFont("courier", 10)
            font1.setBold(True)

            font2 = QtGui.QFont("courier", 9)

            font3 = QtGui.QFont("Courier", 12)
            font3.setBold(True)

            header = []

            margenX, margenY = [25, 75]

            ## HEADER
            x, y = [25, 0]
            header.append([self.impresor.paperRect().width()/2-100, margenY+y, u"Catálogo de Productos", font3])
            x, y = [400, 50]
            header.append([self.impresor.paperRect().width()-200, margenY+y, u"Fecha: %s" % QtCore.QDate().currentDate().toString('dd MMM yyyy'), font1])

            x, y = [0, 100]
            header.append([margenX+x, margenY+y, u"    Código        Nombre                       Clasificación       Cantidad   Precio    Exist", font1])

            tabla = self.ui.tablaConsulta

            x, y = [0, 125]
            contenido = []
            footer = []
            offset = 0
            for row in range(tabla.rowCount()):
                if offset == 0:
                    contenido.extend(header)
                contenido.append([margenX+x    , margenY+y+offset, str(row+1), font2])
                contenido.append([margenX+x+40 , margenY+y+offset, tabla.item(row, 0).text(), font2])      # Código
                contenido.append([margenX+x+150, margenY+y+offset, tabla.item(row, 1).text(), font2])      # Nombre
                contenido.append([margenX+x+375, margenY+y+offset, tabla.item(row, 2).text(), font2])      # Clasificación
                contenido.append([margenX+x+550, margenY+y+offset, tabla.item(row, 3).text(), font2])      # Cantidad
                contenido.append([margenX+x+625, margenY+y+offset, tabla.item(row, 4).text(), font2])      # Precio
                if tabla.item(row, 5):
                    contenido.append([margenX+x+675, margenY+y+offset, tabla.item(row, 5).text(), font2])      # Importe
                offset += 20

                if margenY+y+offset+75 >= self.impresor.paperRect().height():
                    contenido.append([self.impresor.paperRect().width()/2-50, self.impresor.paperRect().height()-50, "Hoja %s" % pageNo, font2])
                    for item in contenido:
                        painter.setFont(item[3])
                        painter.drawText(QtCore.QPoint(margenHorizontal + item[0], margenVertical + item[1]), item[2])
                    offset = 0
                    contenido = []
                    footer = []
                    pageNo += 1
                    self.impresor.newPage()

            contenido.append([self.impresor.paperRect().width()/2-50, self.impresor.paperRect().height()-50, "Hoja %s" % pageNo, font2])
            for item in contenido:
                painter.setFont(item[3])
                painter.drawText(QtCore.QPoint(margenHorizontal + item[0], margenVertical + item[1]), item[2])


    def modifica(self):             # print "productos.igu.Administrador.modifica()"
        if self.ui.tablaConsulta.currentRow() < 0:
            result = QtGui.QMessageBox.information(self, u"Empresa Básica - Modificar producto", u"Selecciona el PRODUCTO que quieres Modificar", QtGui.QMessageBox.Ok, QtGui.QMessageBox.Ok)
        else:
            id = self.ui.tablaConsulta.item(self.ui.tablaConsulta.currentRow(), 0).data(1000).toInt()[0]
            self.owner.captura.modifica(id)


    def mostrarMenuConsulta(self, pos):
        pos = self.ui.tablaConsulta.mapToGlobal(pos)
        self.menuTablaConsulta.popup(pos)


    @property
    def owner(self):
        return self.__owner


    def resizedTablaConsulta(self, event):
        headerWidth = self.ui.tablaConsulta.width()-self.ui.tablaConsulta.verticalHeader().width()-self.ui.tablaConsulta.verticalScrollBar().width()
        self.ui.tablaConsulta.horizontalHeader().setMinimumWidth(headerWidth)

        porcentajes = [12, 24, 13, 13, 10, 9, 9, 9]
        overflow = 0

        x = 0

        for index in range(self.ui.tablaConsulta.horizontalHeader().count()):
            if not self.ui.tablaConsulta.isColumnHidden(index):
                self.ui.tablaConsulta.resizeColumnToContents(index)
                porContenido = self.ui.tablaConsulta.columnWidth(index)
                calculado = headerWidth * porcentajes[index] / 100
                if porContenido < calculado:
                    if overflow:
                        offset = calculado - porContenido
                        if offset > overflow:
                            calculado = calculado - overflow
                            overflow = 0
                        else:
                            overflow -= offset
                            calculado = porContenido
                    x += calculado
                    self.ui.tablaConsulta.setColumnWidth(index, calculado)
                else:
                    overflow += porContenido - calculado


    def selectionChanged(self):     # print "productos.igu.Administrador.selectionChanged()"
        if self.ui.tablaConsulta.currentRow() != -1:
            id = self.ui.tablaConsulta.item(self.ui.tablaConsulta.currentRow(), 0).data(1000).toInt()[0]
            if self.owner.detalles.isVisible():
                self.owner.detalles.mostrar(id)
            if self.owner.captura.isVisible():
                if self.owner.captura.modo == 'modificar':
                    diferent = True
                    if self.owner.captura.old.id == id:
                        diferent = False
                    else:
                        pass
                        # if len(self.owner.captura.old)-1:
                            # if self.owner.captura.old[1].id == id:
                                # diferent = False
                            # else:
                                # if self.owner.captura.isModified():
                                    # result = QtGui.QMessageBox.warning(self, u"Empresa Básica - Modificación de Producto", u"La captura de Producto tiene cambios\n\n¿Quieres Guardar los cambios para %s %s %s?" % (self.owner.captura.old.codigo, self.owner.captura.old.nombre, self.owner.captura.old.producto.clasificacion), QtGui.QMessageBox.Yes | QtGui.QMessageBox.No, QtGui.QMessageBox.No)
                                    # if result == QtGui.QMessageBox.Yes:
                                        # self.owner.captura.guarda(hide=False)
                                        # self.emit(QtCore.SIGNAL("changed()"))
                    if diferent:
                        self.owner.captura.modifica(id)

        self.actualizaBotones()


    def setCurrentId(self, id):
        if not id is None:
            self.ui.tablaConsulta.setCurrentItem(self.ui.tablaConsulta.item(self.findData(id), 0))



class Captura(QtGui.QFrame):

    @property
    def modo(self):
        return self.__modo

    @property
    def rangosPrecioActivos(self):
        return self.owner.rangosPrecioActivos


    def __init__(self, *args, **kwds):
        # self.contenedor = args[0]

        if kwds.has_key('owner'):
            self.__owner = kwds.pop('owner')
        else:
            self.__owner = None

        self.__modo = None

        QtGui.QFrame.__init__(self, *args)

        self.ui = captura_ui.Ui_Form()
        self.ui.setupUi(self)

        font = QtGui.QFont()
        font.setBold(True)
        font.setPointSize(7*controller.app.fontZoom)

        style = 'color:#303030; background-color:#FFFFFF;'

        self.ui.frame.setStyleSheet("QFrame{background-color:#E0E0D0;}")
        self.connect(self.ui.frame, QtCore.SIGNAL('returnPressed()'), self.returnPressed)

        self.ui.titulo.setFrameShape(QtGui.QFrame.Panel)
        self.ui.titulo.setFrameShadow(QtGui.QFrame.Sunken)
        self.ui.titulo.setStyleSheet("background-color:qlineargradient(x1:.5, y1:0, x2:.5, y2:1, stop:0 #F0F0E0, stop:.5 #D0D0D0, stop:1 #F0F0E0); border-top-left-radius: 3px; border-top-right-radius: 3px;")

        self.status = 'init'
        self.old = None

        # self.ui.laLocales.setText("Datos Locales")
        # self.ui.laLocales.setStyleSheet("background-color:qlineargradient(x1:.5, y1:0, x2:.5, y2:1, stop:0 #FFFFF0, stop:1 #C0C0C0)")
        # self.ui.laLocales.setRotation(270)

        # self.ui.frIdentificacion.setStyleSheet("QFrame{background-color:#F0F0C0;}")
        # self.ui.frNiveles.setStyleSheet("QFrame{background-color:#F0F0C0;}")
        # self.ui.frPrecio.setStyleSheet("QFrame{background-color:#F0F0C0;}")

        self.connect(self.ui.aceptionFR_layout, QtCore.SIGNAL('finished()'), self.finished)

        self.ui.frTituloExterno2.setStyleSheet("color:#FFFFFF; background-color:#5F0000;")

        # self.ui.laTituloExterno2.setStyleSheet("color:#FFFFFF; background-color:#00FF00;")
        self.ui.laTituloExterno2.setFont(font)
        self.ui.laTituloExterno2.setOrientation('down')

        self.ui.chHabilitar2.setText("")
        # self.ui.laHabilitar2.setStyleSheet("color:#FFFFFF; background-color:#FF0000;")
        self.ui.laHabilitar2.setOrientation('down')

        self.ui.laGenerales.setStyleSheet("""#laGenerales{
            padding:2px;
            border-top-left-radius:6px;
            border-top-right-radius:6px;
            color:#FFFFFF;
            background-color: #F0A040;
            }""")

        self.ui.laNiveles.setStyleSheet("""#laNiveles{
            padding:2px;
            border-top-left-radius:6px;
            border-top-right-radius:6px;
            color:#FFFFFF;
            background-color:#F0A040;
            }""")

        self.ui.laCostos.setStyleSheet("""#laCostos{
            padding:2px;
            border-top-left-radius:6px;
            border-top-right-radius:6px;
            color:#FFFFFF;
            background-color:#F0A040;
            }""")

        # self.ui.laPrecios.setStyleSheet("""#laPrecios{
        self.ui.pricesLA.setStyleSheet("""#pricesLA{
            padding:2px;
            border-top-left-radius:6px;
            border-top-right-radius:6px;
            color:#FFFFFF;
            background-color:#F0A040;
            }""")

        ## Código
        # self.ui.grCodigo.setStyleSheet("color:#4040C0")
        self.ui.edCodigo.setFont(font)
        self.ui.edCodigo.setAllowedLengths(3, 20)
        self.ui.edCodigo.setPrefijoMensaje(u"El código")
        self.ui.edCodigo.setStyleSheet(style)
        self.connect(self.ui.edCodigo, QtCore.SIGNAL("textEdited(QString)"), self.actualizaStatus)
        # self.connect(self.ui.edCodigo, QtCore.SIGNAL("editingFinished()"), self.actualizaStatus)

        ## Código secundario
        self.ui.edCodigo2.setEmptyAllowed(True)
        self.usarCodigoSecundario = manejador.usarCodigoSecundario()
        if not self.usarCodigoSecundario:
            self.ui.laCodigo2.hide()
            self.ui.edCodigo2.hide()

        ## Nombre
        self.ui.edNombre.setFont(font)
        self.ui.edNombre.setAllowedLengths(4, 50)
        self.ui.edNombre.setCapitalized(True)
        self.ui.edNombre.setPrefijoMensaje(u"El nombre")
        self.ui.edNombre.setStyleSheet(style)
        self.connect(self.ui.edNombre, QtCore.SIGNAL("textEdited(QString)"), self.nombreEditado)

        ## Tipo
        self.ui.cbTipo.setFont(font)
        self.ui.cbTipo.setStyleSheet(style)
        self.connect(self.ui.cbTipo, QtCore.SIGNAL('currentIndexChanged(int)'), self.tipoSeleccionado)
        self.cargaTipos()
        self.ui.cbTipo.setCurrentIndex(self.ui.cbTipo.findData(QtCore.QVariant(manejador.tipoDefault().id)))

        ## Unidad
        self.ui.cbUnidad.setFont(font)
        self.ui.cbUnidad.setStyleSheet(style)
        self.connect(self.ui.cbUnidad, QtCore.SIGNAL('currentIndexChanged(int)'), self.unidadSeleccionada)

        self.cargaUnidades()
        self.ui.cbUnidad.setCurrentIndex(self.ui.cbUnidad.findData(QtCore.QVariant(manejador.unidadDefault().id)))

        ## Clasificación
        self.ui.cbClasificacion.lineEdit().setFont(font)
        self.ui.cbClasificacion.view().setFont(font)
        self.ui.cbClasificacion.setStyleSheet(style)
        self.ui.cbClasificacion.setToolTip("Puede teclear una nueva")
        self.ui.cbClasificacion.completer().setCompletionMode(QtGui.QCompleter.PopupCompletion)
        self.connect(self.ui.cbClasificacion, QtCore.SIGNAL("currentIndexChanged(int)"), self.clasificacionSeleccionada)
        self.connect(self.ui.cbClasificacion.lineEdit(), QtCore.SIGNAL('editingFinished()'), self.actualizaStatus)

        self.cargaClasificaciones()

        # self.loadCapturaClasificacionObligatoria()

        # completer = QtGui.QCompleter([], self.ui.edClasificacion)
        # self.model = Modelo()
        # completer.setModel(self.model)
        # completer.setCaseSensitivity(QtCore.Qt.CaseInsensitive)
        # self.ui.edClasificacion.setCompleter(completer)
        # self.ui.edClasificacion.setFont(font)
        # self.ui.edClasificacion.setToolTip("Puede teclear una nueva")
        # self.ui.edClasificacion.setStyleSheet(style)
        # self.connect(self.ui.edClasificacion, QtCore.SIGNAL("returnPressed()"), self.clasificacionSeleccionada)
        # self.connect(self.ui.edClasificacion, QtCore.SIGNAL('downArrowPressed()'), self.muestraClasificaciones)
        # self.cargaClasificaciones()
        # self.loadCapturaClasificacionObligatoria()

        ## Linea
        self.ui.cbLinea.lineEdit().setFont(font)
        self.ui.cbLinea.setStyleSheet(style)
        self.ui.cbLinea.setToolTip("Puede teclear una nueva")
        # self.ui.cbLinea.completer().setCompletionMode(QtGui.QCompleter.PopupCompletion)
        self.connect(self.ui.cbLinea, QtCore.SIGNAL('currentIndexChanged(int)'), self.lineaChanged)
        self.connect(self.ui.cbLinea.lineEdit(), QtCore.SIGNAL('editingFinished()'), self.actualizaStatus)
        # self.connect(self.ui.cbLinea, QtCore.SIGNAL('lostFocus()'), self.lineaLostFocus)
        self.cargaLineas()

        if not manejador.atributoI(grupo=u'producto', nombre=u'capturaLineaHabilitada').valor:
            self.ui.laLinea.hide()
            self.ui.cbLinea.hide()

        ## Mínimo
        self.ui.edMinimo.setFont(font)
        self.ui.edMinimo.setStyleSheet(style)
        self.ui.edMinimo.setRange(0.00, 9999.99)
        # self.ui.edMinimo.setEmptyAllowed(True)
        self.connect(self.ui.edMinimo, QtCore.SIGNAL("editingFinished()"), self.actualizaStatus)

        ## Maximo
        self.ui.edMaximo.setFont(font)
        self.ui.edMaximo.setStyleSheet(style)
        self.ui.edMaximo.setRange(0.00, 9999.99)
        self.connect(self.ui.edMaximo, QtCore.SIGNAL('editingFinished()'), self.actualizaStatus)

        ## Actual
        self.ui.edActual.setFont(font)
        self.ui.edActual.setStyleSheet(style)
        self.connect(self.ui.edActual, QtCore.SIGNAL('editingFinished()'), self.actualizaStatus)
        self.loadCapturaActualPermitida()

        # Costo Promedio
        # self.ui.edCostoPromedio.setFont(font)
        # self.ui.edCostoPromedio.setStyleSheet(style)
        # self.ui.edCostoPromedio.setDecimals(-1)
        # self.connect(self.ui.edCostoPromedio, QtCore.SIGNAL('editingFinished()'), self.actualizaStatus)

        ## Costo
        self.ui.edCostoPromedio.setFont(font)
        self.ui.edCostoPromedio.setStyleSheet(style)
        self.ui.edCostoPromedio.setDecimals(4)
        self.ui.edCostoPromedio.setRange(0.00, 99999.9999)
        # self.ui.edCosto.hasStatusLabel(False)
        self.connect(self.ui.edCostoPromedio, QtCore.SIGNAL('editingFinished()'), self.calcularCosto)
        # self.connect(self.ui.edCosto, QtCore.SIGNAL("textEdited(QString)"), self.actualizaStatus)
        # self.connect(self.ui.edCosto, QtCore.SIGNAL("textEdited(QString)"), self.edCostoTextEdited)
        # self.connect(self.ui.edCosto, QtCore.SIGNAL("editingFinished()"), self.edCostoEditingFinished)
        # self.connect(self.ui.edCosto, QtCore.SIGNAL("editingFinished()"), self.calcularPrecio)

        ## Impuesto
        self.ui.edImpuesto.setFont(font)
        self.ui.edImpuesto.setStyleSheet(style)
        self.connect(self.ui.edImpuesto, QtCore.SIGNAL('editingFinished()'), self.calcularCosto)
        self.connect(self.ui.edImpuesto, QtCore.SIGNAL('editingFinished()'), self.actualizaStatus)
        self.connect(self.ui.chImpuesto, QtCore.SIGNAL('stateChanged(int)'), self.toggleImpuesto)
        self.connect(self.ui.chImpuesto, QtCore.SIGNAL('stateChanged(int)'), self.priceCalc)
        self.ui.chImpuesto.setChecked(False)
        self.ui.chImpuesto.setChecked(True)
        self.ui.chImpuesto.setChecked(manejador.dameImpuestoEnabled())
        impuesto = manejador.impuestoGeneral()
        self.ui.edImpuesto.setText("%s" % impuesto)

        ## Costo neto
        self.ui.edCostoNeto.setDecimals(4)
        self.connect(self.ui.edCostoNeto, QtCore.SIGNAL('textEdited(QString)'), self.priceCalc)

        ## Margen Base
        self.connect(self.ui.baseED, QtCore.SIGNAL('textEdited(QString)'), self.priceCalc)

        ## Precios
        for row, rango in enumerate(manejador.rangosPrecio()):

            self.ui.pricesTA.insertRow(row)

            adjust = cdNumberEdit.CDNumberEdit(self)
            adjust.setFrame(False)
            adjust.setStyleSheet(style)
            self.connect(adjust, QtCore.SIGNAL('textEdited(QString)'), self.priceCalc)
            self.ui.pricesTA.setCellWidget(row, 0, adjust)

            discount = cdNumberEdit.CDNumberEdit(self)
            discount.setFrame(False)
            discount.setStyleSheet(style)
            self.connect(discount, QtCore.SIGNAL('textEdited(QString)'), self.priceCalc)
            self.ui.pricesTA.setCellWidget(row, 1, discount)

            item = QtGui.QTableWidgetItem("")
            item.setTextAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignVCenter)
            self.ui.pricesTA.setItem(row, 2, item)

            item = QtGui.QTableWidgetItem("")
            item.setTextAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignVCenter)
            self.ui.pricesTA.setItem(row, 3, item)

            item = QtGui.QTableWidgetItem("")
            item.setTextAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignVCenter)
            self.ui.pricesTA.setItem(row, 4, item)

            priceFinal = cdNumberEdit.CDNumberEdit()
            priceFinal.setFrame(False)
            priceFinal.setStyleSheet(style)
            self.connect(priceFinal, QtCore.SIGNAL('textEdited(QString)'), self.priceCalc)
            self.ui.pricesTA.setCellWidget(row, 5, priceFinal)

            item = QtGui.QTableWidgetItem(rango.nombre)
            self.ui.pricesTA.setVerticalHeaderItem(row, item)

        self.ui.pricesTA.horizontalHeader().setResizeMode(0, QtGui.QHeaderView.Stretch)
        self.ui.pricesTA.horizontalHeader().setResizeMode(1, QtGui.QHeaderView.Stretch)
        self.ui.pricesTA.horizontalHeader().setResizeMode(2, QtGui.QHeaderView.Stretch)
        self.ui.pricesTA.horizontalHeader().setResizeMode(4, QtGui.QHeaderView.Stretch)
        self.ui.pricesTA.resizeColumnToContents(3)
        self.ui.pricesTA.resizeColumnToContents(5)

        global MARGIN_ADJUST, MARGIN_DISCOUNT, MARGIN_CALC, PRICE_CALC, MARGIN_FINAL, PRICE_FINAL

        MARGIN_ADJUST, MARGIN_DISCOUNT, MARGIN_CALC, PRICE_CALC, MARGIN_FINAL, PRICE_FINAL = range(6)


        ## ACEPCIONES
        self.ui.aceptionsTB = AceptionsCapture(self)

        self.ui.aceptionsLY.addWidget(self.ui.aceptionsTB)

        self.connect(self.ui.chHabilitar, QtCore.SIGNAL('stateChanged(int)'), self.toggleExterno)
        self.connect(self.ui.chHabilitar2, QtCore.SIGNAL('stateChanged(int)'), self.toggleExterno)

        self.toggleExterno(QtCore.Qt.Unchecked)

        ## Aceptar
        # self.ui.boAceptar.hide()

        ## Agregar
        # self.connect(self.ui.boAgregar, QtCore.SIGNAL('clicked()'), self.agregaAcepcion)
        # self.ui.boAgregar.hide()

        ## Eliminar
        # self.ui.boEliminar.hide()

        # self.connect(self.ui.boAceptar, QtCore.SIGNAL('clicked()'), self.aceptaAcepcion)

        # self.ui.slideCaptura.ui.edCosto.setValidator(validator)
        # valor = self.owner.bd.get("variables", {'tipo':'sistema', 'nombre':'impuestoDefault'})['valor']
        # validator = QtGui.QRegExpValidator(expresion, self.ui.edMargen)
        # self.ui.slideCaptura.ui.edMargen.setValidator(validator)

        # self.ui.cbClasificacion.defaultText = "Seleccione"

        ## Comentarios
        self.ui.comentarios.show()

        icon = QtGui.QIcon()
        icon.addPixmap(QtGui.QPixmap("imagenes/Info.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
        self.ui.boComentarios.setIcon(icon)
        self.ui.boComentarios.setIconSize(QtCore.QSize(32,24))
        # self.ui.boComentarios.setText(u"Ocultar información")
        self.ui.boComentarios.status = 'on'
        self.connect(self.ui.boComentarios, QtCore.SIGNAL('clicked()'), self.toggleComentarios)

        self.toggleComentarios()
        # self.ui.toComentarios.setText(u"Ocultar información")
        # self.ui.toComentarios.status = 'on'
        # self.connect(self.ui.toComentarios, QtCore.SIGNAL('clicked()'), self.toggleComentarios)

        ## Guardar
        icon = QtGui.QIcon()
        icon.addPixmap(QtGui.QPixmap("imagenes/Check.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
        self.ui.boGuardar.setIcon(icon)
        self.ui.boGuardar.setIconSize(QtCore.QSize(32,24))
        self.ui.boGuardar.setDefault(True)
        self.ui.boGuardar.setEnabled(False)
        self.connect(self.ui.boGuardar, QtCore.SIGNAL("clicked()"), self.guarda)

        ## Cancelar
        icon = QtGui.QIcon()
        icon.addPixmap(QtGui.QPixmap("imagenes/Cancel.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
        self.ui.boCancelar.setIcon(icon)
        self.ui.boCancelar.setIconSize(QtCore.QSize(32,24))
        self.connect(self.ui.boCancelar, QtCore.SIGNAL("clicked()"), self.cancela)

        self.connect(controller.eventRouter, QtCore.SIGNAL("clasificacionesChangedBroadcast()"), self.cargaClasificaciones)

        self.connect(controller.eventRouter, QtCore.SIGNAL("lineasChangedBroadcast()"), self.cargaLineas)

        self.connect(controller.eventRouter, QtCore.SIGNAL('capturaActualPermitidaChangedBroadcast'), self.loadCapturaActualPermitida)

        self.connect(controller.eventRouter, QtCore.SIGNAL('capturaLineaToggledBroadcast()'), self.actualizaCapturaLinea)

        # self.connect(self.eventRouter, QtCore.SIGNAL('capturaClasificacionObligatoriaChangedBroadcast'), self.loadCapturaClasificacionObligatoria)

        self.connect(controller.eventRouter, QtCore.SIGNAL('rangosPrecioChangedBroadcast()'), self.rangosPrecioChanged)

        self.connect(controller.eventRouter, QtCore.SIGNAL('usarCodigoSecundarioChangedBroadcast()'), self.usarCodigoSecundarioChanged)

        # self.connect(self.parent(), QtCore.SIGNAL('tipoProductoDefaultChangedBroadcast'), self.loadTipoProductoDefault)

        self.setTabOrder(self.ui.edCodigo, self.ui.edNombre)
        self.setTabOrder(self.ui.edNombre, self.ui.cbTipo)
        self.setTabOrder(self.ui.cbTipo, self.ui.cbUnidad)
        self.setTabOrder(self.ui.cbUnidad, self.ui.cbLinea)
        self.setTabOrder(self.ui.cbLinea, self.ui.cbClasificacion)
        self.setTabOrder(self.ui.cbClasificacion, self.ui.edCostoPromedio)
        self.setTabOrder(self.ui.edCostoPromedio, self.ui.edImpuesto)
        self.setTabOrder(self.ui.edImpuesto, self.ui.edCostoNeto)
        self.setTabOrder(self.ui.edCostoNeto, self.ui.edMinimo)

        self.setTabOrder(self.ui.edMinimo, self.ui.edMaximo)
        self.setTabOrder(self.ui.edMaximo, self.ui.edActual)
        # self.setTabOrder(self.ui.edActual, self.ui.edMargen1)

        # self.setTabOrder(self.ui.edMargen1, self.ui.edAjuste1)
        # self.setTabOrder(self.ui.edAjuste1, self.ui.edDescuento1)
        # self.setTabOrder(self.ui.edDescuento1, self.ui.edMargenF1)
        # self.setTabOrder(self.ui.edMargenF1, self.ui.edPrecio1)
        # self.setTabOrder(self.ui.edPrecio1, self.ui.chHabilitar)

        self.setTabOrder(self.ui.edActual, self.ui.chHabilitar)

        self.setTabOrder(self.ui.chHabilitar, self.ui.boCancelar)

        self.setTabOrder(self.ui.boCancelar, self.ui.boGuardar)
        self.setTabOrder(self.ui.boGuardar, self.ui.boComentarios)
        self.setTabOrder(self.ui.boComentarios, self.ui.comentarios)

        self.mensajes = u""
        self.acepciones = {}

        self.status = 'normal'

    # def tipoCostoClicked(self):
        # if self.buTipoCosto.text() == u'Bruto':
            # self.ui.buTipoCosto.setText(u'Neto')
        # elif self.buTipoCosto.text() == u'Neto':
            # self.ui.buTipoCosto.setText(u'Bruto')
            # self.ui.


    def actualizaCapturaLinea(self):
        self.capturaLineaHabilitada = manejador.capturaLineaHabilitada()
        if not self.capturaLineaHabilitada:
            self.ui.laLinea.hide()
            self.ui.cbLinea.hide()
            # self.ui.laLinea.setStyleSheet("color:#FFFFFF; background-color:#C0D0FF")
        else:
            self.ui.laLinea.show()
            self.ui.cbLinea.show()
            # self.ui.laLinea.setStyleSheet("color:#FFFFFF; background-color:#80A0FF")
        self.actualizaStatus()


    def actualizaStatus(self, *args):
        if self.status==u'normal':

            if self.isModified:
                if self.modo == 'modificar':
                    if self.isValid:
                        self.ui.boGuardar.setEnabled(True)
                        self.ui.boGuardar.setToolTip(self.mensajes2)
                        self.ui.comentarios.setText(self.mensajes2)
                    else:
                        self.ui.boGuardar.setEnabled(False)
                        self.ui.boGuardar.setToolTip(self.mensajes)
                        self.ui.comentarios.setText("%s\n\n%s" % (self.mensajes, self.mensajes2))
                elif self.modo == 'agregar':
                    if self.isValid:
                        self.ui.boGuardar.setEnabled(True)
                        self.ui.boGuardar.setToolTip(u'OK')
                        self.ui.comentarios.setText(u'OK')
                    else:
                        self.ui.boGuardar.setEnabled(False)
                        self.ui.boGuardar.setToolTip(self.mensajes)
                        self.ui.comentarios.setText(self.mensajes)
            else:
                self.ui.boGuardar.setEnabled(False)
                self.ui.boGuardar.setToolTip(u"No hay cambios")
                self.ui.comentarios.setText(self.mensajes)
        else:
            pass
            # print 'skipped'
            # don't test on init


    # def actualizaStatusAcepcion(self):
        # m = "productos.igu.Captura.actualizaStatusAcepcion()"
        # print (1), m, self.acepciones

        # if self.acepcionEsValida():
            # self.ui.boAgregar.setEnabled(True)      # No importa si esta enabled o no
            # self.ui.boAgregar.setToolTip(u"")
        # else:
            # self.ui.boAgregar.setEnabled(False)
            # self.ui.boAgregar.setToolTip(self.mensajesAcepcion)


    def agrega(self):
        m = "productos.igu.Captura.agrega()"

        self.ui.titulo.setText(QtGui.QApplication.translate("Empresa Básica", "Producto nuevo", None, QtGui.QApplication.UnicodeUTF8))
        self.__modo = 'agregar'

        self.clear()

        self.acepciones = {}

        self.ui.edCodigo.setFocus()

        self.actualizaStatus()

        self.owner.setInnerStatus('hidden')

        self.show()

        self.ui.pricesTA.setMinimumHeight(self.ui.pricesTA.rowHeight(0) * self.ui.pricesTA.rowCount() + self.ui.pricesTA.horizontalHeader().height() + 2)
        self.ui.pricesTA.setMaximumHeight((self.ui.pricesTA.rowHeight(0)+1) * self.ui.pricesTA.rowCount() + self.ui.pricesTA.horizontalHeader().height())


    def cancela(self):
        self.clear()
        self.hide()
        self.ui.frLocal.setEnabled(True)
        self.ui.frLocal.setToolTip(u"")
        self.emit(QtCore.SIGNAL("capturaClosed()"))


    def calcularCosto(self):
        costoNeto = self.ui.edCostoPromedio.value() * (100+self.ui.edImpuesto.value()) / 100
        self.ui.edCostoNeto.setValue(costoNeto)
        self.priceCalc()


    def calcularPrecio(self, data=None):
        print "productos.igu.Captura.calcularPrecio() interveened"
        f=g

        if self.status == 'normal':
            costoNeto = self.ui.edCostoNeto.value()

            if self.ui.chImpuesto.isChecked():
                impuesto = self.ui.edImpuesto.value()
            else:
                impuesto = dec("0.00")

            margen = self.ui.baseED.value()

            for index, rango in enumerate(manejador.rangosPrecio()):
                descuento = self.ui.discountED[index].value()
                margenF = ((100+self.ui.baseED.value()) * (100+self.ui.adjustED[index].value())/100 * (100-self.ui.discountED[index].value())/100)-100
                self.ui.netED[index].setValue(margenF)
                precio = costoNeto * (100+margenF) / 100
                oldFocused = self.focusWidget()
                old = self.ui.calcED[index].text()
                self.ui.calcED[index].setValue(precio)

            self.actualizaStatus()


    def cargaClasificaciones(self):
        clasificaciones = manejador.clasificaciones()

        self.ui.cbClasificacion.clear()

        for clasificacion in clasificaciones:
            self.ui.cbClasificacion.addItem(clasificacion.nombre, QtCore.QVariant(clasificacion.id))

        self.ui.cbClasificacion.setCurrentIndex(self.ui.cbClasificacion.findText(u''))


    def cargaLineas(self):
        p = "productos.igu.Captura.cargaLineas()"
        registros = manejador.lineas()
        self.ui.cbLinea.clear()
        for registro in registros:
            self.ui.cbLinea.addItem(registro.nombre, QtCore.QVariant(registro.id))
        self.ui.cbLinea.setCurrentIndex(-1)


    # def cargaProveedores(self):         # print "productos.igu.Captura.cargaProveedores()"
        # old = self.ui.cbProveedor.itemData(self.ui.cbProveedor.currentIndex())
        # self.ui.cbProveedor.clear()
        # proveedores = manejador.proveedores()
        # if proveedores:
            # for item in proveedores:
                # self.ui.cbProveedor.addItem("%s %s" % (item.entidad.nombre, item.entidad.nombre2), QtCore.QVariant(item.id))
        # else:
            # self.ui.cbProveedor.addItem(u"No hay proveedores registrados")
        # if old > 0:
            # self.ui.cbProveedor.setCurrentIndex(self.ui.cbProveedor.findData(old))


    def cargaTipos(self):
        tipos = manejador.tipos()
        self.ui.cbTipo.clear()
        for tipo in tipos:
            self.ui.cbTipo.addItem(tipo.nombre, QtCore.QVariant(tipo.id))


    def cargaUnidades(self):
        unidades = manejador.unidades()
        self.ui.cbUnidad.clear()
        for unidad in unidades:
            self.ui.cbUnidad.addItem(unidad.nombre, QtCore.QVariant(unidad.id))


    def clasificacionSeleccionada(self, completerModelIndex=None): # print "productos.igu.Captura.clasificacionSeleccionada()",
        if self.status==u'normal':
            self.actualizaStatus()
        # else:
            # print 'skipped'


    def clear(self):                    # print "productos.igu.Captura.clear()"
        self.ui.edCodigo.clear()
        self.ui.edNombre.clear()
        self.ui.cbClasificacion.setCurrentIndex(self.ui.cbClasificacion.findText(u''))
        self.ui.edMinimo.setText("0")
        self.ui.edMaximo.setText("0")
        self.ui.edActual.setText("0")
        self.ui.edCostoPromedio.setText("0.00")
        self.ui.edCostoNeto.setText("0.00")
        # self.ui.edMargen1.setText("0")

        ## PRECIOS
        for index, rango in enumerate(self.rangosPrecioActivos):
            self.ui.pricesTA.cellWidget(index, MARGIN_ADJUST).setText('')
            self.ui.pricesTA.cellWidget(index, MARGIN_DISCOUNT).setText('')
            self.ui.pricesTA.item(index, MARGIN_CALC).setText('')
            self.ui.pricesTA.item(index, PRICE_CALC).setText('')
            self.ui.pricesTA.item(index, MARGIN_FINAL).setText('')
            self.ui.pricesTA.cellWidget(index, PRICE_FINAL).setText('')
            self.ui.pricesTA.cellWidget(index, PRICE_FINAL).setStyleSheet('')

        ## ACEPCIONES
        self.ui.aceptionsTB.clear()


    # def creaBoton(self, rol):
        # index = len(self.acepciones)

        # self.botonesProveedor.append(QtGui.QToolButton(self.ui.aceptionFR))
        # self.botonesProveedor[index].setText("%s %s" % (rol.entidad.nombre, rol.entidad.nombre2))
        # self.botonesProveedor[index].setCheckable(True)
        # self.botonesProveedor[index].setAutoExclusive(True)

        # sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Preferred, QtGui.QSizePolicy.Fixed)
        # sizePolicy.setHorizontalStretch(0)
        # sizePolicy.setVerticalStretch(0)
        # sizePolicy.setHeightForWidth(self.botonesProveedor[index].sizePolicy().hasHeightForWidth())
        # self.botonesProveedor[index].setSizePolicy(sizePolicy)

        # self.ui.layoutBotones.insertWidget(0, self.botonesProveedor[index])

        # self.connect(self.botonesProveedor[index], QtCore.SIGNAL('clicked()'), self.proveedorClicked)

        # self.botonesProveedor[index].rolId = rol.id
        # self.botonesProveedor[index].setChecked(True)



    def data(self):
        """ Regresa los datos contenidos en los widgets de captura y un
            estatus de validez de formato generado por los mismos."""
        datos = {}
        if self.modo == 'modificar':
            datos['id'] = self.old.id

        datos['codigo'] = unicode(self.ui.edCodigo.text())
        if self.usarCodigoSecundario:
            datos['codigo2'] = unicode(self.ui.edCodigo2.text())
        datos['nombre'] = unicode(self.ui.edNombre.text())
        datos['tipo_id'] = self.ui.cbTipo.itemData(self.ui.cbTipo.currentIndex()).toInt()[0]
        datos['unidad_id'] = self.ui.cbUnidad.itemData(self.ui.cbUnidad.currentIndex()).toInt()[0]

        ## Línea
        if self.ui.cbLinea.findText(self.ui.cbLinea.currentText()) == -1:
            datos['linea'] = unicode(self.ui.cbLinea.currentText())
        else:
            datos['linea_id'] = self.ui.cbLinea.itemData(self.ui.cbLinea.currentIndex()).toInt()[0]

        ## Clasificación
        if not self.ui.cbClasificacion.isHidden():
            if self.ui.cbClasificacion.findText(self.ui.cbClasificacion.currentText()) == -1:
                datos['clasificacion'] = unicode(self.ui.cbClasificacion.currentText())
            else:
                datos['clasificacion_id'] = self.ui.cbClasificacion.itemData(self.ui.cbClasificacion.currentIndex()).toInt()[0]

        datos['minimo'] = self.ui.edMinimo.value()
        datos['maximo'] = self.ui.edMaximo.value()
        datos['actual'] = self.ui.edActual.value()
        datos['costopromedio'] = self.ui.edCostoPromedio.value()
        datos['impuesto'] = self.ui.edImpuesto.value()
        # datos['descuentoIndividual'] = self.ui.edDescuento1.value()
        datos['descuentoIndividual'] = dec('0')

        datos['margen'] = self.ui.baseED.value()

        ## PRECIOS
        prices = []
        for index, rango in enumerate(self.rangosPrecioActivos):
            price = {}
            price['adjust'] = self.ui.pricesTA.cellWidget(index, MARGIN_ADJUST).value()
            price['discount'] = self.ui.pricesTA.cellWidget(index, MARGIN_DISCOUNT).value()
            price['value'] = self.ui.pricesTA.cellWidget(index, PRICE_FINAL).value()
            price['reference'] = rango.id

            prices.append(price)

            pass
            # exec('''datos['ajuste%s'] = self.ui.edAjuste%s.value()''' % (index+1, index+1))
            # exec('''datos['descuento%s'] = self.ui.edDescuento%s.value()''' % (index+1, index+1))
            # exec('''datos['precio%s'] = self.ui.edPrecio%s.value()''' % (index+1, index+1))
            # exec('''datos['referencia%s'] = rango.id''' % (index+1))

        datos['prices'] = prices

        aceptions = self.ui.aceptionsTB.data()
        if aceptions:
            datos['acepciones'] = aceptions

        return datos




    def finished(self):
        m = "productos.igu.Captura.finished()"
        if not self.ui.aceptionFR_layout.slideStatus:
            # self.ui.frTituloExterno2.hide()
        # else:
            self.ui.frTituloExterno2.show()

    @property
    def isModified(self):
        data = self.data()
        # valor = False
        self.mensajes2 = u""

        productoIsModified = False

        if self.ui.edCodigo.isModified:
            productoIsModified = True
            self.mensajes2 += u"Código modificado\n"

        if self.usarCodigoSecundario:
            if self.ui.edCodigo2.isModified:
                productoIsModified = True
                self.mensajes2 += u'Código auxiliar modificado\n'

        if self.ui.edNombre.isModified:
            productoIsModified = True
            self.mensajes2 += u"Nombre modificado\n"

        ## Clasificacion - Se asume una sola clasificacion
        if self.ui.cbClasificacion.isModified:
        # if 'clasificacion' in data.keys() or data['clasificacion_id'] != oldProducto.clasificacion_id:
            productoIsModified = True
            self.mensajes2 += u"Clasificación modificada\n"

        ## Línea - Se asume una sola línea
        if self.ui.cbLinea.isModified:
            productoIsModified = True
            self.mensajes2 += u"Linea modificada\n"
        # lineaList = [x for x in oldProducto.atributos if x.nombre==u'linea']
        # if lineaList:
            # linea = lineaList[0]
            # if data['linea'][1] != int(linea.valor):
                # testProducto = True
                # self.mensajes2 += u"Linea modificada\n"
        # else:
            # if data['linea'][0]:
                # testProducto = True
                # self.mensajes2 += u"Linea modificada\n"

        if self.ui.cbTipo.isModified:
            productoIsModified = True
            self.mensajes2 += u"Tipo de producto modificado\n"

        if self.ui.edMinimo.isModified:
            productoIsModified = True
            self.mensajes2 += u"Inventario mínimo modificado\n"

        if self.ui.edMaximo.isModified:
            productoIsModified = True
            self.mensajes2 += u"Inventario máximo modificado\n"

        if self.ui.edActual.isModified:
            productoIsModified = True
            self.mensajes2 += u"Inventario actual modificado\n"

        if self.ui.edCostoPromedio.isModified:
            productoIsModified = True
            self.mensajes2 += u"Costo promedio modificado\n"

        if self.ui.edImpuesto.isModified:
            productoIsModified = True
            self.mensajes2 += u"Impuesto modificado\n"

        # if self.ui.edMargen1.isModified:
            # productoIsModified = True
            # self.mensajes2 += u"Margen modificado\n"


        ## PRECIOS
        for index, rango in enumerate(manejador.rangosPrecio()):

            if self.ui.pricesTA.cellWidget(index, MARGIN_ADJUST).isModified:
                productoIsModified = True
                self.mensajes2 += u"Ajuste de margen %s modificado\n" % rango.nombre

            if self.ui.pricesTA.cellWidget(index, MARGIN_DISCOUNT).isModified:
                productoIsModified = True
                self.mensajes2 += u"Descuento en margen %s modificado\n" % rango.nombre

            if self.ui.pricesTA.cellWidget(index, PRICE_FINAL).isModified:
                productoIsModified = True
                self.mensajes2 += u"Precio final %s modificado\n" % rango.nombre

        ## Aceptions
        if self.ui.aceptionsTB.isModified:
            productoIsModified = True
            self.mensajes2 += self.ui.aceptionsTB.messagesModified

        self.mensajes2 = self.mensajes2.rstrip(u"\n")

        return productoIsModified


    @property
    def isValid(self):
        valida = True
        self.mensajes = ""

        if self.ui.edCodigo.isEmpty:
            valida = False
            self.mensajes += u"Falta el código\n"
        else:
            self.validarCodigo()
            if not self.ui.edCodigo.isValid:
                valida = False
                self.mensajes += u"%s\n" % self.ui.edCodigo.message()

        if self.usarCodigoSecundario:
            self.validarCodigo()
            if not self.ui.edCodigo2.isValid:
                valida = False
                self.mensajes += u"%s\n" % self.ui.edCodigo2.message()

        if self.ui.edNombre.isEmpty:
            valida = False
            self.mensajes += u"Falta el nombre\n"
        else:
            if not self.ui.edNombre.isValid:
                valida = False
                self.mensajes += u"%s\n" % self.ui.edNombre.message()

        # if not self.ui.cbClasificacion.isValid:
            # valida = False
            # if self.ui.edClasificacion.isEmpty:
                # self.mensajes += u"Debes capturar una clasificación\n"
            # else:
                # self.mensajes += u"%s\n" % self.ui.edClasificacion.message()

        if manejador.capturaClasificacionObligatoria():
            if not self.ui.cbClasificacion.currentText():
                valida = False
                self.mensajes += u"Debes capturar una clasificación\n"

        if not self.ui.edCostoPromedio.isValid:
            valida = False
            self.mensajes += u"El costo promedio no es válido\n"

        for index, rango in enumerate(manejador.rangosPrecio()):
            if rango.referencia[1] == 'a':
                if not self.ui.pricesTA.cellWidget(index, PRICE_FINAL).value():
                    valida = False
                    self.mensajes += u"Falta definir el precio %s\n" % rango.nombre

        # if self.ui.edPrecio1.value() == dec("0"):
            # valida = False
            # self.mensajes += u"Falta el Precio\n"
        # else:
            # if not self.ui.edPrecio1.isValid:
                # valida = False
                # self.mensajes += u"El precio no es válido\n"

        ## Aceptions
        if self.ui.chHabilitar.isChecked():
            if not self.ui.aceptionsTB.isValid:
                valida = False
                self.mensajes += self.ui.aceptionsTB.messages

        validaTemp, mensajes = manejador.valida(self.data(), self.modo)
        if not validaTemp:
            valida = False
            self.mensajes += mensajes

        self.mensajes = self.mensajes.rstrip("\n")

        return valida


    def guarda(self, **kwds):
        print "productos.igu.Captura.guarda()"

        ## No se revisa validez de datos, para llegar aquí se tuvo que haber hecho

        self.setCursor(QtCore.Qt.WaitCursor)

        datos = self.data()
        # datos['acepciones'] = self.datosAcepciones()

        if self.modo == 'agregar':
            id = manejador.agrega(datos)
            status = self.agrega()
        else:
            manejador.modifica(datos)

        controller.eventRouter.emit(QtCore.SIGNAL("productosChangedBroadcast()"))

        if 'clasificacion' in datos.keys():
            controller.eventRouter.emit(QtCore.SIGNAL("clasificacionesChangedBroadcast()"))

        if 'linea' in datos.keys():
            controller.eventRouter.emit(QtCore.SIGNAL("lineasChangedBroadcast()"))

        if kwds.has_key('hide'):
            if kwds['hide']:
                self.hide()
                self.emit(QtCore.SIGNAL('capturaClosed()'))
        else:
            self.hide()
            self.emit(QtCore.SIGNAL('capturaClosed()'))

        # self.ui.frLocal.setEnabled(True)
        # self.ui.frLocal.setToolTip(u"")
        self.setCursor(QtCore.Qt.ArrowCursor)


    def lineaChanged(self):
        self.actualizaStatus()


    def lineaEdited(self):
        if self.ui.cbLinea.findText(self.ui.cbLinea.currentText(), QtCore.Qt.MatchStartsWith) == -1:
            self.ui.cbLinea.setStyleSheet("background-color:#FFFF60;")
        else:
            self.ui.cbLinea.setStyleSheet("background-color:#FFFFFF;")
        self.actualizaStatus()


    def lineaLostFocus(self):
        if self.ui.cbLinea.findText(self.ui.cbLinea.currentText(), QtCore.Qt.MatchStartsWith) == -1:
            self.ui.cbLinea.setStyleSheet("background-color:#FFFF60;")
        else:
            self.ui.cbLinea.setStyleSheet("background-color:#FFFFFF;")
            self.ui.cbLinea.setCurrentIndex(self.ui.cbLinea.findText(self.ui.cbLinea.currentText(), QtCore.Qt.MatchStartsWith))
        self.actualizaStatus()


    def loadCapturaActualPermitida(self):
        self.capturaActualPermitida = manejador.capturaActualPermitida()
        if not self.capturaActualPermitida:
            self.ui.edActual.setEnabled(False)
            self.ui.laActual.setStyleSheet("color:#FFFFFF; background-color:#C0D0FF;")
            # self.ui.frCostoPromedio.setEnabled(False)
        else:
            self.ui.edActual.setEnabled(True)
            self.ui.laActual.setStyleSheet("color:#FFFFFF; background-color:#80A0FF;")
            # self.ui.frCostoPromedio.setEnabled(True)
        self.actualizaStatus()


    # def loadCapturaClasificacionObligatoria(self): # print "productos.igu.Captura.loadCapturaClasificacionObligatoria()"
        # self.capturaClasificacionObligatoria = manejador.capturaClasificacionObligatoria()
        # if manejador.capturaClasificacionObligatoria():
            # self.ui.edClasificacion.setEmptyAllowed(False)
        # else:
            # self.ui.edClasificacion.setEmptyAllowed(True)
        # self.actualizaStatus()


    # def minimoAcepcionEditado(self, texto):
        # if self.rolId:
            # self.acepciones["%s" % self.rolId]['referencia'] = unicode(self.ui.edMinimoP.text())
        # self.actualizaStatus()


    def modifica(self, id):
        """ Recibe: id de Acepcion
        """

        self.ui.titulo.setText(QtGui.QApplication.translate("Empresa Básica", "Modificación de Producto", None, QtGui.QApplication.UnicodeUTF8))

        self.clear()
        self.__modo = 'modificar'


        acepcion = manejador.acepcionI(id=id)


        self.setData(acepcion.producto)

        self.actualizaStatus()

        self.owner.setInnerStatus('hidden')

        self.show()

        self.owner.administrador.ui.tablaConsulta.scrollToItem(self.owner.administrador.ui.tablaConsulta.item(self.owner.administrador.findData(id), 1), QtGui.QAbstractItemView.EnsureVisible)


    def nombreEditado(self, texto):
        # if len(self.ui.edNombre.text()) == 1:
            # self.ui.edNombre.setText(unicode(self.ui.edNombre.text()).capitalize())
        self.actualizaStatus()


    @property
    def owner(self):
        return self.__owner


    def precioEdited(self, text):
        m = "productos.igu.Captura.precioEdited(%s)" % text

        self.actualizaStatus()


    def priceCalc(self, text=None):
        if self.status == 'normal':
            costoNeto = self.ui.edCostoNeto.value()

            if self.ui.chImpuesto.isChecked():
                impuesto = self.ui.edImpuesto.value()
            else:
                impuesto = dec("0.00")

            margen = self.ui.baseED.value()

            recalcular = manejador.atributoI(grupo=u'producto', nombre=u'recalcularPrecioAlComprar').valor == u'1'
            sentido = manejador.atributoI(grupo=u'producto', nombre=u'sentidoDeCambio').valor
            allowedMarginDiff = dec(manejador.atributoI(grupo=u'producto', nombre=u'margenDeCambio').valor)
            # if sentido == u'+/-':
                # self.ui.raMasMenos.setChecked(True)
            # elif sentido == u'+':
                # self.ui.raMas.setChecked(True)

            for index, rango in enumerate(manejador.rangosPrecio()):
                print 123, index
                adjust = self.ui.pricesTA.cellWidget(index, MARGIN_ADJUST).value()
                discount = self.ui.pricesTA.cellWidget(index, MARGIN_DISCOUNT).value()
                # descuento = self.ui.discountED[index].value()
                marginCalc = (((100+self.ui.baseED.value()) * (100+adjust)/100 * (100-discount)/100)-100).quantize(dec('0.01'))
                self.ui.pricesTA.item(index, MARGIN_CALC).setText("%s" % marginCalc)
                # self.ui.netED[index].setValue(margenF)

                priceCalc = (costoNeto * (100+marginCalc) / 100).quantize(dec('0.0001'))
                print 124, priceCalc
                oldFocused = self.focusWidget()
                oldPrice = self.ui.pricesTA.item(index, PRICE_CALC).text()
                self.ui.pricesTA.item(index, PRICE_CALC).setText("%s" % priceCalc)

                if recalcular:
                    priceFinal = self.ui.pricesTA.cellWidget(index, PRICE_FINAL).value()
                    if priceFinal:
                        diff = ( priceFinal - priceCalc ) / priceFinal * dec('100')

                        if abs(diff) > allowedMarginDiff:
                            if not (diff < 0 and "-" not in sentido):
                                self.ui.pricesTA.cellWidget(index, PRICE_FINAL).setStyleSheet("background-color:#FFA0A0;")
                        else:
                            self.ui.pricesTA.cellWidget(index, PRICE_FINAL).setStyleSheet("")
                    else:
                        self.ui.pricesTA.cellWidget(index, PRICE_FINAL).setValue(priceCalc)
                        self.ui.pricesTA.cellWidget(index, PRICE_FINAL).setStyleSheet("")

                if costoNeto:
                    marginFinal = (self.ui.pricesTA.cellWidget(index, PRICE_FINAL).value() / costoNeto * 100).quantize(dec('0.01'))
                else:
                    marginFinal = dec('0')

                self.ui.pricesTA.item(index, MARGIN_FINAL).setText("%s" % marginFinal)

            self.actualizaStatus()


    # def proveedorClicked(self):
        # m = "productos.igu.Captura.proveedorClicked()"

        # if self.sender().isChecked():
            # self.registraDatosAcepcion()
            # self.rolId = self.sender().rolId
            # self.setAceptionData(self.acepciones['%s' % self.rolId])
        # else:
            # self.sender().setChecked(True)

    def rangosPrecioChanged(self):
        m = "productos.igu.Captura.rangosPrecioChanged()"

        for index, rango in enumerate(manejador.rangosPrecio()):
            if rango.referencia[1]==u'a':
                exec('''self.ui.edAjuste%s.show()''' % (index+1))
                exec('''self.ui.edDescuento%s.show()''' % (index+1))
                exec('''self.ui.edMargenF%s.show()''' % (index+1))
                exec('''self.ui.edPrecio%s.show()''' % (index+1))
            else:
                exec('''self.ui.edAjuste%s.hide()''' % (index+1))
                exec('''self.ui.edDescuento%s.hide()''' % (index+1))
                exec('''self.ui.edMargenF%s.hide()''' % (index+1))
                exec('''self.ui.edPrecio%s.hide()''' % (index+1))
        self.calcularPrecio()


    def returnPressed(self):            # print "productos.igu.Captura.returnPressed()"
        if self.ui.boGuardar.isEnabled():
            self.guarda()


    def setData(self, producto):
        self.old = producto

        self.status = 'setting data'

        ## Clasificación
        if producto.clasificacion:
            self.ui.cbClasificacion.setInitialText(producto.clasificacion.nombre)

        ## LINEA
        if producto.lineas:
            # linea = manejador.atributoI(id=int(producto.lineas[0].valor))
            self.ui.cbLinea.setInitialText(producto.lineas[0].nombre)

        if producto.tipo_id:
            tipo = manejador.atributoI(id=producto.tipo_id)
            self.ui.cbTipo.setInitialText(tipo.nombre)

        # if producto.minimo:
        self.ui.edMinimo.setInitialValue(producto.minimo)

        # if producto.maximo:
        self.ui.edMaximo.setInitialValue(producto.maximo)

        # if producto.actual:
        self.ui.edActual.setInitialValue(producto.actual)

        self.ui.edCostoPromedio.setInitialValue(producto.costopromedio)
        self.ui.edImpuesto.setInitialValue(producto.impuesto)
        self.ui.edCostoNeto.setInitialValue(producto.costopromedio*(100+producto.impuesto)/100)

        # if data[0].descuentoindividual:
            # self.ui.edDescuento.setText("%.2f" % data[0].descuentoindividual)

        if producto.margen:
            self.ui.baseED.setInitialValue(producto.margen)

        # self.ui.edPrecio.setText("%s" % data[0].producto.precio)

        # precios = [x for x in producto.precios if x.id==self.rangosPrecioActivos[0].id]

        ## PRECIOS      [ ajuste, descuento, margenNeto, precio ]

        for row, rango in enumerate(manejador.rangosPrecio()):

            if rango.referencia[1] == 'a':
                precioZero = [ x for x in  producto.precios if x.atributo_id==rango.id ]

                if precioZero:
                    price = precioZero[0]

                    costoNeto = self.ui.edCostoNeto.value()

                    marginCalc = (((100+producto.margen) * (100+dec(price.factor1))/100 * (100-dec(price.factor2))/100)-100).quantize(dec('0.01'))

                    priceCalc = (costoNeto * (100 + marginCalc) / 100).quantize(dec('0.0001'))

                    self.ui.pricesTA.cellWidget(row, 0).setInitialValue(dec(price.factor1), actualToo=True)
                    self.ui.pricesTA.cellWidget(row, 1).setInitialValue(dec(price.factor2), actualToo=True)
                    self.ui.pricesTA.item(row, 2).setText("%s" % marginCalc)

                    self.ui.pricesTA.item(row, 3).setText("%s" % priceCalc)

                    marginFinal = (((dec(price.valor) / costoNeto - 1 ) * dec('100'))-dec('100')).quantize(dec('0.01'))

                    self.ui.pricesTA.item(row, 4).setText("%s" % marginFinal)

                    self.ui.pricesTA.cellWidget(row, 5).setInitialValue(dec(price.valor), actualToo=True)

                self.ui.pricesTA.resizeColumnToContents(3)
                # self.ui.pricesTA.resizeColumnToContents(5)
                self.ui.pricesTA.horizontalHeader().setResizeMode(5, QtGui.QHeaderView.Stretch)

        ## Acepciones

        self.ui.aceptionsTB.clear()

        local = [x for x in producto.acepciones if x.rol_id == controller.app.holder.id][0]
        self.ui.edCodigo.setInitialText("%s" % local.codigo)
        self.ui.edNombre.setInitialText(local.nombre)

        external = [x for x in producto.acepciones if x.rol_id != controller.app.holder.id]

        if external:
            self.ui.aceptionsTB.setData(external)

            self.ui.chHabilitar.setChecked(True)
            self.ui.aceptionFR_layout.sizeOut()
        else:
            self.ui.chHabilitar.setChecked(False)
            self.ui.aceptionFR_layout.sizeIn()

        self.status = 'normal'


    def tipoSeleccionado(self, index):
        self.actualizaStatus()


    def toggleComentarios(self):
        if self.ui.boComentarios.status==u'on':
            self.ui.comentarios.hide()
            self.ui.boComentarios.status=u'off'
            # self.ui.boComentarios.setText(u'Mostrar información')
        else:
            self.ui.comentarios.show()
            self.ui.boComentarios.status=u'on'
            # self.ui.boComentarios.setText(u'Ocultar información')


    def toggleDescuento(self, state):
        m = "productos.igu.Captura.toggleDescuento() #! empty"
        print (1), m

        # if state==QtCore.Qt.Checked:
            # self.ui.edDescuento.setEnabled(True)
            # self.ui.chDescuento.setStyleSheet("color:#FFFFFF; background-color:#80A0FF")
        # else:
            # self.ui.edDescuento.setEnabled(False)
            # self.ui.chDescuento.setStyleSheet("color:#FFFFFF; background-color:#C0D0FF")


    def toggleImpuesto(self, state):
        if state==QtCore.Qt.Checked:
            self.ui.edImpuesto.setEnabled(True)
            self.ui.chImpuesto.setStyleSheet("color:#FFFFFF; background-color:#80A0FF;")
        else:
            self.ui.edImpuesto.setEnabled(False)
            self.ui.chImpuesto.setStyleSheet("color:#FFFFFF; background-color:#C0D0FF;")


    def toggleExterno(self, state):
        m = "productos.igu.Captura.toggleExterno()"
        print (1), m, state

        if state == QtCore.Qt.Checked:
            self.ui.chHabilitar.setChecked(True)
            self.ui.frTituloExterno2.hide()
            self.ui.aceptionFR_layout.sizeOut()
            self.actualizaStatus()
        else:
            self.ui.chHabilitar2.setChecked(False)
            self.ui.aceptionFR_layout.sizeIn()
            self.actualizaStatus()


    def unidadSeleccionada(self, index): # print "productos.igu.Captura.unidadSeleccionada()"
        self.actualizaStatus()


    def usarCodigoSecundarioChanged(self):
        self.usarCodigoSecundario = manejador.usarCodigoSecundario()
        if not self.usarCodigoSecundario:
            self.ui.laCodigo2.hide()
            self.ui.edCodigo2.hide()
        else:
            self.ui.laCodigo2.show()
            self.ui.edCodigo2.show()


    def validarCodigo(self, text=""):   # print "productos.igu.Captura.validarCodigo()"
        oldFocused = self.focusWidget()

        self.ui.edCodigo.setExternalValidation(True, u"")

        if self.modo == 'modificar':
            if self.ui.edCodigo.isModified:
                acepcionExiste = manejador.acepcionExists(codigo=unicode(self.ui.edCodigo.text()), rol_id=controller.app.holder.id)
                if acepcionExiste:
                    self.ui.edCodigo.setExternalValidation(False, u"El código ya está en uso\n")

        elif self.modo == 'agregar':
            acepcionExiste = manejador.acepcionExists(codigo=unicode(self.ui.edCodigo.text()), rol_id=controller.app.holder.id)
            if acepcionExiste:
                ## Checar si se desea agregar una acepción a un producto existente
                self.ui.edCodigo.setExternalValidation(False, u"El código ya está en uso\n")
                # if self.ui.frLocal.isEnabled():
                    # acepcion = manejador.acepcionI(codigo=unicode(self.ui.edCodigo.text()), rol_id=controller.app.holder.id)
                    # result = QtGui.QMessageBox.warning(self, u"Empresa Básica - Código existente", u"Este código es del producto local\n\n%s, %s\n\n¿Quieres agregarle datos a ese producto?" % (acepcion.nombre, acepcion.producto.clasificacion.nombre), QtGui.QMessageBox.Yes | QtGui.QMessageBox.No, QtGui.QMessageBox.No)
                    # if result == QtGui.QMessageBox.Yes:
                        # self.ui.frLocal.setEnabled(False)
                        # self.ui.frLocal.setToolTip(u"Para modificar estos datos, cierre esta ventana, seleccione el producto en la lista de productos y presione Modificar")
                        # data = {}
                        # data['acepcion'] = acepcion
                        # self.setData(data)
                    # else:
                        # self.ui.edCodigo.setExternalValidation(False, u"El código ya existe\n")

        if oldFocused:
            oldFocused.setFocus()


    def validarCodigo2(self, text=""):
        print "productos.igu.Captura.validarCodigo2()"

        oldFocused = self.focusWidget()
        f=g
        acepcion = manejador.acepcionI(rol_id=controller.app.holder.id, referencia=unicode(self.ui.edCodigo2.text()))

        self.ui.edCodigo2.setExternalValidation(True, u"")
        if acepcion:
            if self.modo == 'agregar':
                self.ui.edCodigo2.setExternalValidation(True, u"El código auxiliar ya existe\n")
        if oldFocused:
            oldFocused.setFocus()
        #~ self.actualizaStatus()


class Detalles(QtGui.QFrame):

    # @property
    # def eventRouter(self):
        # return self.contenedor.eventRouter

    def __init__(self, *args, **kwds):
        # self.contenedor = args[0]

        if kwds.has_key('owner'):
            self.__owner = kwds.pop('owner')
        else:
            self.__owner = None

        QtGui.QFrame.__init__(self, *args)

        self.ui = detalles_ui.Ui_Form()
        self.ui.setupUi(self)

        self.ui.spacerX = []
        self.ui.laEntidadX = []
        self.ui.laCodigoX = []
        self.ui.laNombreX = []
        self.ui.laCostoX = []
        self.ui.laDescuentoX = []

        self.connect(controller.eventRouter, QtCore.SIGNAL('productosChangedBroadcast()'), self.actualiza)

        self.id = None


    def actualiza(self, id=None):    # print "productos.igu.Detalles.actualiza()"
        if id:
            pass
        elif self.id:
            acepcion = manejador.acepcionI(id=self.id)

            acepcionLocal = [x for x in acepcion.producto.acepciones if x.rol_id==controller.app.holder.id][0]

            self.clear()

            self.ui.laCodigo.setText("%s" % acepcionLocal.codigo)
            self.ui.laNombre.setText(acepcionLocal.nombre)
            self.ui.laTipo.setText(manejador.tipo(id=acepcionLocal.producto.tipo_id).nombre)
            self.ui.laUnidad.setText(manejador.unidad(id=acepcionLocal.producto.unidad_id).nombre)
            self.ui.laClasificacion.setText(acepcionLocal.producto.clasificacion.nombre)
            self.ui.laLinea.setText(acepcionLocal.producto.lineas[0].nombre)

            self.ui.laMinimo.setText("%s" % acepcionLocal.producto.minimo)
            self.ui.laMaximo.setText("%s" % acepcionLocal.producto.maximo)
            self.ui.laActual.setText("%s" % acepcionLocal.producto.actual)

            self.ui.laCosto.setText("%.2f" % acepcionLocal.producto.costopromedio)
            self.ui.laImpuesto.setText("%.2f" % acepcionLocal.producto.impuesto)

            self.ui.laMargen.setText("%.2f" % acepcionLocal.producto.margen)

            ## PRECIOS
            for index, rango in enumerate(self.owner.rangosPrecioActivos):
                atributoCero = [x for x in acepcionLocal.producto.precios if x.atributo_id==rango.id]
                if atributoCero:
                    atributo = atributoCero[0]
                    # exec('''self.ui.laAjuste%s.setText("%.2f")''' % (index+1, dec(atributo.factor1)))
                    # exec('''self.ui.laDescuento%s.setText("%s")''' % (index+1,  atributo.factor2))
                    # exec('''self.ui.laMargenF%s.setText("%s")''' % (index+1, (acepcionLocal.producto.margen * (100+dec(atributo.factor1))/100 * (100-dec(atributo.factor2))/100).quantize(dec('0.01'))))
                    # exec('''self.ui.laPrecio%s.setText("%.2f")''' % (index+1, dec(atributo.valor)))

            if self.ui.spacerX:
                self.ui.spacerX.pop()

            font = QtGui.QFont()
            font.setBold(True)
            font.setPointSize(8*controller.app.fontZoom)

            offset = 22

            index = 0
            for acepcion in acepcion.producto.acepciones:
                if acepcion.rol_id != controller.app.holder.id:

                    if len(self.ui.laCodigoX) >= index:
                        self.ui.spacerX.append(QtGui.QSpacerItem(20, 20, QtGui.QSizePolicy.Minimum, QtGui.QSizePolicy.Preferred))
                        self.ui.gridLayout.addItem(self.ui.spacerX[index], offset+1+index*6, 1, 1, 1)

                        self.ui.laEntidadX.append(QtGui.QLabel(self.ui.frameDetalle))
                        self.ui.laEntidadX[index].setFont(font)
                        self.ui.gridLayout.addWidget(self.ui.laEntidadX[index], offset+1+index*6, 0, 1, 4)

                        self.ui.laCodigoX.append([QtGui.QLabel(u"Código", self.ui.frameDetalle), QtGui.QLabel(self.ui.frameDetalle)])
                        self.ui.laCodigoX[index][1].setFont(font)
                        self.ui.gridLayout.addWidget(self.ui.laCodigoX[index][0], offset+2+index*6, 0, 1, 1)
                        self.ui.gridLayout.addWidget(self.ui.laCodigoX[index][1], offset+2+index*6, 1, 1, 1)

                        self.ui.laNombreX.append([QtGui.QLabel(u"Nombre", self.ui.frameDetalle), QtGui.QLabel(self.ui.frameDetalle)])
                        self.ui.laNombreX[index][1].setFont(font)
                        self.ui.gridLayout.addWidget(self.ui.laNombreX[index][0], offset+3+index*6, 0, 1, 1)
                        self.ui.gridLayout.addWidget(self.ui.laNombreX[index][1], offset+3+index*6, 1, 1, 3)

                        self.ui.laCostoX.append([QtGui.QLabel(u"Costo", self.ui.frameDetalle), QtGui.QLabel(self.ui.frameDetalle)])
                        self.ui.laCostoX[index][1].setFont(font)
                        self.ui.gridLayout.addWidget(self.ui.laCostoX[index][0], offset+4+index*6, 0, 1, 1)
                        self.ui.gridLayout.addWidget(self.ui.laCostoX[index][1], offset+4+index*6, 1, 1, 1)

                        self.ui.laDescuentoX.append([QtGui.QLabel(u"Descuento", self.ui.frameDetalle), QtGui.QLabel(self.ui.frameDetalle)])
                        self.ui.laDescuentoX[index][1].setFont(font)
                        self.ui.gridLayout.addWidget(self.ui.laDescuentoX[index][0], offset+5+index*6, 0, 1, 1)
                        self.ui.gridLayout.addWidget(self.ui.laDescuentoX[index][1], offset+5+index*6, 1, 1, 1)

                    self.ui.laEntidadX[index].setText("%s %s" % (acepcion.rol.entidad.nombre, acepcion.rol.entidad.nombre2))
                    self.ui.laEntidadX[index].show()
                    self.ui.laCodigoX[index][1].setText("%s" % acepcion.codigo)
                    self.ui.laCodigoX[index][1].show()
                    self.ui.laCodigoX[index][0].show()
                    self.ui.laNombreX[index][1].setText("%s" % acepcion.nombre)
                    self.ui.laNombreX[index][1].show()
                    self.ui.laNombreX[index][0].show()
                    self.ui.laCostoX[index][1].setText("%s" % acepcion.costo)
                    self.ui.laCostoX[index][1].show()
                    self.ui.laCostoX[index][0].show()
                    self.ui.laDescuentoX[index][1].setText("%s" % acepcion.descuentogeneral)
                    self.ui.laDescuentoX[index][1].show()
                    self.ui.laDescuentoX[index][0].show()

                    index += 1

            self.ui.spacerX.append(QtGui.QSpacerItem(20, 20, QtGui.QSizePolicy.Preferred, QtGui.QSizePolicy.Expanding))
            self.ui.gridLayout.addItem(self.ui.spacerX[len(acepcion.producto.acepciones)-1], offset+6+(len(acepcion.producto.acepciones)-1)*6, 1, 1, 1)


    def clear(self):
        self.ui.laCodigo.clear()
        self.ui.laNombre.clear()
        self.ui.laClasificacion.clear()
        self.ui.laCosto.clear()
        self.ui.laImpuesto.clear()
        self.ui.laMargen.clear()
        self.ui.laAjuste1.clear()
        self.ui.laDescuento1.clear()
        self.ui.laMargenF1.clear()
        self.ui.laPrecio1.clear()
        self.ui.laMinimo.clear()
        self.ui.laMaximo.clear()
        self.ui.laActual.clear()
        for index in range(len(self.ui.laCodigoX)):
            self.ui.laEntidadX[index].hide()
            self.ui.laCodigoX[index][0].hide()
            self.ui.laCodigoX[index][1].hide()
            self.ui.laNombreX[index][0].hide()
            self.ui.laNombreX[index][1].hide()
            self.ui.laCostoX[index][0].hide()
            self.ui.laCostoX[index][1].hide()
            self.ui.laDescuentoX[index][0].hide()
            self.ui.laDescuentoX[index][1].hide()


    def mostrar(self, id):
        self.id = id
        self.clear()
        self.actualiza()
        self.show()


    @property
    def owner(self):
        return self.__owner



class Splitter(QtGui.QSplitter):

    def __init__(self, *args):
        self.orientation = args[0]
        QtGui.QSplitter.__init__(self, *args)

    def createHandle(self):
        return Handle(self.orientation, self)



class Handle(QtGui.QSplitterHandle):

    def __init__(self, *args):
        QtGui.QSplitterHandle.__init__(self, *args)

    def mouseDoubleClickEvent(self, event): # print "Handle.mousePressEvent()"
        self.emit(QtCore.SIGNAL("handlePressed"))


class Modelo(QtCore.QAbstractListModel):

    def __init__(self, *args):
        QtCore.QAbstractListModel.__init__(self, *args)
        self.__data = []

    def clear(self):
        self.beginRemoveRows(QtCore.QModelIndex(), 0, self.rowCount())
        self.__data = []
        self.endRemoveRows()

    def data(self, index, role=QtCore.Qt.DisplayRole):  # print "productos.igu.Modelo.data()"
        if index.row() != -1:
            if role in [QtCore.Qt.DisplayRole]:
                return self.__data[index.row()][0]
            elif role in [QtCore.Qt.EditRole]:
                return self.__data[index.row()][1]
            elif role == QtCore.Qt.TextAlignmentRole:
                return QtCore.QVariant(int(QtCore.Qt.AlignLeft|QtCore.Qt.AlignVCenter))
            elif role == QtCore.Qt.UserRole:
                return self.__data[index.row()][2]
        return QtCore.QVariant()

    def insertRow(self, row, parent=QtCore.QModelIndex()):  # print "productos.igu.Modelo.insertRow()"
        self.__data.insert(row, [QtCore.QVariant(u""), QtCore.QVariant(u""), QtCore.QVariant(u"")])
        return True

    def rowCount(self, parent=QtCore.QModelIndex()):
        return len(self.__data)

    def reload(self):
        pass

    def setData(self, index, valor, role=QtCore.Qt.DisplayRole):
        if role == QtCore.Qt.DisplayRole:
            self.__data[index.row()][0] = QtCore.QVariant(valor)
        elif role == QtCore.Qt.EditRole:
            self.__data[index.row()][1] = QtCore.QVariant(valor)
        elif role == QtCore.Qt.UserRole:
            self.__data[index.row()][2] = QtCore.QVariant(valor)
        else:
            print 12345, role
        return True


class AceptionsCapture(QtGui.QTabWidget):

    def __init__(self, *args):

        QtGui.QTabWidget.__init__(self, *args)

        self.ui = aceptionsCapture_ui.Ui_TabWidget()
        self.ui.setupUi(self)

        self.connect(self, QtCore.SIGNAL('currentChanged(int)'), self.currentChanged)


    def currentChanged(self, index):
        if self.status == u'normal':
            if self.tabText(index) == '+':
                nuevo = [x for x in range(self.count()) if self.tabText(x) == 'Nuevo']
                if not nuevo:
                    tab = CapturaAcepcion()
                    self.insertTab(1, tab, "Nuevo")
                    self.setCurrentIndex(1)


    def clear(self):
        self.status = u'clearing'

        QtGui.QTabWidget.clear(self)

        tab = QtGui.QWidget()
        self.addTab(tab, "+")

        tab = CapturaAcepcion()
        self.insertTab(1, tab, "Nuevo")
        self.setCurrentIndex(1)

        self.status = u'normal'


        # for index in range(self.count()):
            # widget = self.ui.aceptionWidgets.pop(self.ui.aceptionWidgets.keys()[0])
            # self.removeTab(self.ui.aceptionsTB.indexOf(widget))
            # widget.destroy()

        # self.ui.aceptionWidgets['+'] = CapturaAcepcion()

        # index = self.ui.aceptionsTB.addTab(self.ui.aceptionWidgets['+'], 'Nuevo')
        # self.ui.aceptionsTB.setCurrentIndex(index)
        # self.connect(self.ui.aceptionWidgets['+'], QtCore.SIGNAL('updateStatus()'), self.actualizaStatus)


    def data(self):
        data = []

        for tabIndex in range(self.count()):
            if self.tabText(tabIndex) not in ['+']:
                aceptionFR = self.widget(tabIndex)

                print aceptionFR.ui.codeED.text()

                data.append(aceptionFR.data())

        return data

        # if not self.rolId:
            # self.rolId = self.ui.cbProveedor.itemData(self.ui.cbProveedor.currentIndex()).toInt()[0]

        # datos['rol_id'] = self.rolId

        # datos['codigo'] = unicode(self.ui.edCodigoP.text())
        # datos['nombre'] = unicode(self.ui.edNombreP.text())
        # datos['costo']  = self.ui.edCostoP.value()
        # datos['descuentogeneral'] = self.ui.edDescuentoP.value()
        # datos['referencia'] = "%s" % self.ui.edMinimoP.value()

        # if "%s" % self.rolId not in self.acepciones.keys():
            # rol = manejador.rolI(id=self.rolId)
            # self.creaBoton(rol)

        # self.acepciones["%s" % self.rolId] = datos




    def modifiedData(self):
        data = []

        acepciones = self.data()

        # if self.old:
            # print "edit"

            # repeat = True
            # index = 0

            # while repeat:

                # if index < len(self.old):

                    # self.old[index].


        # else:
            # print "add"


        return data


    def registraDatos(self):
        datos = {}

        if not self.rolId:
            self.rolId = self.ui.cbProveedor.itemData(self.ui.cbProveedor.currentIndex()).toInt()[0]

        datos['rol_id'] = self.rolId

        datos['codigo'] = unicode(self.ui.edCodigoP.text())
        datos['nombre'] = unicode(self.ui.edNombreP.text())
        datos['costo']  = self.ui.edCostoP.value()
        datos['descuentogeneral'] = self.ui.edDescuentoP.value()
        datos['referencia'] = "%s" % self.ui.edMinimoP.value()

        if "%s" % self.rolId not in self.acepciones.keys():
            rol = manejador.rolI(id=self.rolId)
            self.creaBoton(rol)

        self.acepciones["%s" % self.rolId] = datos


    # def descuentoAcepcionEditado(self, texto):
        # self.acepciones["%s" % self.rolId]['descuentogeneral'] = unicode(self.ui.edDescuentoP.text())
        # self.actualizaStatus()


    @property
    def isModified(self):
        isModified = False
        self.messagesModified = u''

        # for index, key in enumerate(self.ui.aceptionWidgets.keys()):
            # widget = self.ui.aceptionWidgets[key]
            # if widget.isModified:
                # isModified = True
                # self.messagesModified += widget.messagesModified + '\n'

        self.messagesModified.rstrip(u"\n")

        return isModified


    @property
    def isValid(self):
        isValid = True
        self.messages = u''

        # for index, key in enumerate(self.ui.aceptionWidgets.keys()):
            # widget = self.ui.aceptionWidgets[key]

            # if not widget.isValid:
                # isValid = False

        self.messages.rstrip(u'\n')

        return isValid


    def setData(self, aceptions):
        self.clear()

        for aception in aceptions:
            tab = CapturaAcepcion()
            self.addTab(tab, "%s %s" % (aception.rol.entidad.nombre, aception.rol.entidad.nombre2))

            tab.setData(aception)

        self.setCurrentIndex(1)



class CapturaAcepcion(QtGui.QFrame):

    def __init__(self, *args, **kwds):

        QtGui.QFrame.__init__(self, *args)

        self.ui = capturaAcepcion_ui.Ui_Frame()
        self.ui.setupUi(self)

        ## Se carga los proveedores al inicio, cualquier actualización se reflejará automáticamente mediante un broadcast.
        self.updateSuppliers()

        self.connect(self.ui.supplierCB, QtCore.SIGNAL('activated(int)'), self.changedSupplier)

        self.connect(self.ui.codeED, QtCore.SIGNAL("textEdited(QString)"), self.editedCode)
        self.connect(self.ui.nameED, QtCore.SIGNAL("textEdited(QString)"), self.editedName)
        self.ui.costED.setEmptyAllowed(False)
        self.connect(self.ui.costED, QtCore.SIGNAL("editingFinished()"), self.editedCost)
        self.connect(self.ui.discountED, QtCore.SIGNAL("textEdited(QString)"), self.editedDiscount)
        self.connect(self.ui.minimumPackingED, QtCore.SIGNAL("textEdited(QString)"), self.editedMinimumPacking)

        self.connect(controller.eventRouter, QtCore.SIGNAL('proveedoresChangedBroadcast()'), self.updateSuppliers)

        self.setTabOrder(self.ui.supplierCB, self.ui.codeED)
        self.setTabOrder(self.ui.codeED, self.ui.nameED)
        self.setTabOrder(self.ui.nameED, self.ui.costED)
        self.setTabOrder(self.ui.costED, self.ui.discountED)
        self.setTabOrder(self.ui.discountED, self.ui.minimumPackingED)

        self.old = None


    def changedSupplier(self):
        self.updateStatus()


    def clear(self):
        """ Sólo borra la captura actual """

        self.ui.supplierCB.setCurrentIndex(-1)
        self.ui.codeED.clear()
        self.ui.nameED.clear()
        self.ui.costED.setValue(dec("0.00"))
        self.ui.discountED.setValue(dec("0.00"))
        self.ui.minimumPackingED.setValue(dec("1"))

        self.ui.supplierLA.show()
        self.ui.supplierCB.show()

        self.ui.boAgregar.setEnabled(False)

        self.rolId = None


    def data(self):
        data = {}
        data['codigo'] = self.ui.codeED.text()
        data['nombre'] = self.ui.nameED.text()
        data['costo'] = unicode(self.ui.costED.text())
        data['descuento'] = unicode(self.ui.discountED.text())
        data['referencia'] = unicode(self.ui.minimumPackingED.text())

        return data


    def editedCode(self, texto):
        # if self.rolId:
            # self.acepciones["%s" % self.rolId]['codigo'] = unicode(self.ui.edCodigoP.text())
        self.updateStatus()


    def editedCost(self):
        # self.acepciones["%s" % self.rolId]['costo'] = unicode(self.ui.edCostoP.text())
        self.updateStatus()


    def editedDiscount(self, texto):
        # self.acepciones["%s" % self.rolId]['descuentogeneral'] = unicode(self.ui.edDescuentoP.text())
        self.updateStatus()


    def editedMinimumPacking(self, texto):
        # if self.rolId:
            # self.acepciones["%s" % self.rolId]['referencia'] = unicode(self.ui.edMinimoP.text())
        self.updateStatus()


    def editedName(self, texto):
        # if self.rolId:
            # self.acepciones["%s" % self.rolId]['nombre'] = unicode(self.ui.edNombreP.text())
        self.updateStatus()


    @property
    def isModified(self):
        isModified = False
        self.messagesModified = u''

        if self.old:        # Si el modo es edit
            message = "%s %s" % (self.old.rol.entidad.nombre, self.old.rol.entidad.nombre2)
        else:
            message = "proveedor nuevo"

        if self.ui.codeED.isModified:
            isModified = True
            self.messagesModified += u"    Código modificado para %s\n" % message

        if self.ui.nameED.isModified:
            isModified = True
            self.messagesModified += u"    Nombre modificado para %s\n" % message

        if self.ui.discountED.isModified:
            isModified = True
            self.messagesModified += u"    Descuento modificado para %s\n" % message

        if self.ui.minimumPackingED.isModified:
            isModified = True
            self.messagesModified += u"    Empaque mínimo modificado para %s\n" % message

        self.messagesModified = self.messagesModified.rstrip("\n")

        return isModified


    @property
    def isValid(self):

        valid = True
        self.messages = u""

        if self.old:        # Si el modo es edit
            message = "para %s %s" % (self.old.rol.entidad.nombre, self.old.rol.entidad.nombre2)
        else:
            message = "para nuevos datos de proveedor"

        if not( not self.old and self.ui.supplierCB.currentIndex<0 and self.ui.codeED.isEmpty and self.ui.nameED.isEmpty and self.ui.costED.value()==dec('0') ):

            # Esto se redefine en la validación externa
            # if self.ui.supplierFR.width():
                # if self.ui.supplierCB.currentIndex() < 0:
                    # valid = False
                    # self.messages += u"Debe seleccionar un proveedor %s\n" % message

            if self.ui.codeED.isEmpty:
                valid = False
                self.messages += u"Falta el código %s\n" % message
            else:
                self.validateCode()
                # if not self.ui.codeED.isValid:
                    # valid = False
                    # self.messages += u"%s %s\n" % (self.ui.codeED.message(), message)

            # if self.ui.nameED.isEmpty:
                # valid = False
                # self.messages += u"Falta el nombre %s\n" % message
            # else:
                # if not self.ui.nameED.isValid:
                    # valid = False
                    # self.messages += u"%s %s\n" % (self.ui.nameED.message(), message)

            # if self.ui.costED.value() == dec("0"):
                # valid = False
                # self.messages += u"Falta el Costo %s\n" % message
            # else:
                # if not self.ui.costED.isValid:
                    # valid = False
                    # self.messages += u"El costo no es válido %s\n" % message

        self.messages = self.messages.rstrip("\n")

        return valid


    def setData(self, data):
        self.ui.codeED.setInitialText(data.codigo, actualToo=True)
        self.ui.nameED.setInitialText(data.nombre, actualToo=True)
        self.ui.costED.setInitialValue(data.costo, actualToo=True)
        self.ui.discountED.setInitialValue(data.descuentogeneral, actualToo=True)
        if not data.referencia is None:
            self.ui.minimumPackingED.setInitialValue(dec(data.referencia), actualToo=True)

        self.ui.supplierFR.setMaximumWidth(0)

        self.old = data


    def updateStatus(self):
        # if self.isValid:
            # self.ui.boAgregar.setEnabled(True)      # No importa si esta enabled o no
            # self.ui.boAgregar.setToolTip(u"")
        # else:
            # self.ui.boAgregar.setEnabled(False)
            # self.ui.boAgregar.setToolTip(self.mensajesAcepcion)

        self.emit(QtCore.SIGNAL(u'updateStatus()'))


    def updateSuppliers(self):
        old = self.ui.supplierCB.itemData(self.ui.supplierCB.currentIndex())

        self.ui.supplierCB.clear()

        suppliers = manejador.proveedores()

        if suppliers:
            for supplier in suppliers:
                self.ui.supplierCB.addItem("%s %s" % (supplier.entidad.nombre, supplier.entidad.nombre2), QtCore.QVariant(supplier.id))
        else:
            self.ui.supplierCB.addItem(u"No hay proveedores registrados")
        if old > 0:
            self.ui.supplierCB.setCurrentIndex(self.ui.supplierCB.findData(old))


    def validateCode(self, text=""):
        oldFocused = self.focusWidget()

        if self.ui.supplierFR.width():
            if self.ui.supplierCB.currentIndex() == -1:
                self.ui.codeED.setExternalValidation(False, u"Requiere seleccionar un proveedor para validar código")
            else:
            # if self.old.rol_id == controller.app.holder.id:
                acepcion = manejador.dameAcepcion(codigo=unicode(self.ui.codeED.text()), rol_id=self.ui.supplierCB.itemData(self.ui.supplierCB.currentIndex()).toInt()[0])
                self.ui.codeED.setExternalValidation(True, u"")
                if acepcion:
                    if self.modo == 'modificar':
                        if acepcion.id == self.old[self.ui.tabbar.currentIndex()+1].id:
                            pass
                        else:
                            self.ui.codeED.setExternalValidation(False, u"El código según proveedor ya existe\n")
                    elif self.modo == 'agregar':
                        self.ui.codeED.setExternalValidation(False, u"El código según proveedor ya existe\n")

            # if oldFocused:
                # print 4222, oldFocused.objectName()
                # oldFocused.setFocus()



""" This is a GUI module
    It's only purpose is to interact with the user to show him data and
    to obtain data from him.
    To enforce this, al data obtained from the user will be containde in
    dictionaries mapped to data entering widgets.
    All data processing must be made at the manager (manejador) module.

Issues
    Detalles se confundirá cuando el número de rangos de precio activos aumente, ya
    que no tendrá registro para los productos capturados anteriormente.


Lineamientos para registros
    Se utilizan 3 tipos de registros:
        - Base, datos únicos (no requieren
            más de una instancia), datos que no cambian (tipo, unidad, etc)
            o datos que cambian rara vez (costo promedio, impuesto, etc)

        - Renta, datos que definen la rentabilidad

        - Complemento, datos que requieren mas de una instancia para
            una misma base (acepciones)
        - Variables, datos que cambian constantemente (existencia actual)
        - Atributos, datos que requieren más de una instancia (precios, ubicaciones)

    Cada dato al sufrir un cambio provoca la creación de un registro sombra
    del registro que lo contiene, el registro sombra contiene los datos como
    estaban antes del cambio, mas la fecha del cambio.

    Esto permite reproducir el estado de la base de datos en cualquier momento.
    PEj, reproducir exactamente la captura de una factura a pesar de que hayan
    cambiado los datos los productos, se puede accesar los precios que se tenian
    al momento de la captura de la factura (datos que no quedan plasmados en los
    registros de la factura).

PRODUCTO
id                  inmutable
tipo_id
unidad_id
clasificacion_id

margen
impuesto
precio

minimo
maximo
actual

fechaalta
fechabaja
status

ACEPCION


Producto            Producto2   Acepción            Atributo
(esencia)           (renta)     control)           (control)
id                  id          id                  id
tipo                margen      producto_id         acepcion_id
clasificacion_id    impuesto    rol_id              tipo            precio      linea       base
unidad_id           costo       codigo              valor           50.00       att_id      margen=50
                                nombre              factor1         descuento=0             impuesto
                                costo
                                descuento
                                referencia
                                minimo
                                maximo
                                actual
fechaalta                       fechaalta           fechaalta
fechabaja                       fechabaja           fechabaja
status                          status              status




Atributo    ( Precio, Linea,

id
producto_id
nombre
valor
factor1
factor2
referencia
usuario
status
fechaalta
fechabaja


Precio      (Atributo)  - Requiere más de una instancia y varias referencias
                            (tipo, descuento, etc)
Línea       (Atributo)  - Requiere más de una instancia

Nombre      (Acepción)  - Requiere más de una instancia






"""

